python基础学习笔记

 #!/usr/bin/env python
 #coding=utf-8

 def login(username):
     if username=='bill':
         return 1
     else:
         return 0

 def detail(user):
     print '我是%s'%user

 if __name__=='__main__':
     user=raw_input('请输入你的名字：')
     if login(user) == 1:
         print '登陆成功'
         if raw_input('是否显示详细y/n') == 'y':
             detail(user)
         else:
             print 'ok'
     else:
         print '登陆失败'

函数的默认参数，如果默认没有赋值，则会只是默认值，如果给具体的某个键，就要加上具体的键

 def foo(name,action='砍柴',where='上海'):
     print name,'去',action,where

 if __name__=='__main__':
     foo('zhangsan')
     foo('lili','chipi')
     foo('adf',where='北京')

以键值形式存储

 def foo(**item):
     for i in item.items():
         print i

 foo(name='a',age='b')

如果此时是字典要存入，则需要使用一下模式

 def foo(**item):
     for i in item.items():
         print i

 a={'name':'weiwei','age':''}

 foo(**a)

以列表形式存储

 def foo(*item):
     for i in item:
         print i

 foo('a','b','')

xrange与range  readlines()与xreadlines()区别就是没有x的是一次性向内存开辟空间，而有x的则是使用一个开辟一个空间

 yield的返回值是一个生成器，只有遍历的时候才会返回值
 def foo():
     yield 1

 a=foo()
 for i in a:
     print i
 迭代器和生成器的区别，迭代器会有一个next()方法，一直向下执行，生成器会将数据记录为一个快照，暂时不开辟内存空间，等到有for循环打印出来的时候就需要开辟内存空间了

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

 三元运算式
 result='ge' if 1<3 else 'it'
 print result
 结果ge

 num=lambda x,y:x+y#lambda关键字

 print num(4,10)
 结果14，三个参数也可以，参数由自己设定

 内置函数：
 print bool(1)#布尔值
 print abs(-9)
 print divmod(1,9)#求模

 print max(11,22)
 print min(11,22)
 print sum([11,22])
 print pow(2,10)

 a=[1]
 print len(a)
 #如果a是文字，则此时就是字节的长度，不是字符的长度

 print all([1,2,3,4,1])
 print any([2,3,4,1,23])
 any(iterable)说明：参数iterable：可迭代对象；
 如果当iterable所有的值都是0、''或False时，那么结果为False，如果所有元素中有一个值非0、''或False，那么结果就为True
 如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；

 print chr(66)#ASCII对应的数据
 print ord('a')#打印对应的95

 print hex(2)#转换成16进制
 print bin(2)#转换成2进制
 print oct(2)#转换成8进制

 li=['手表','起床','房']#enumerate会将数组或列表组成一个索引序列，2是起始的序号，可随意修改
 for item in enumerate(li,2):
     print item[0],item[1]
 0 one
 1 two
 2 three

 s='i am {0} {1}'
 print s.format('bill','jj')

对序列里面的每个元素操作

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

对序列过滤，返回结果为true的留下，false的顾虑掉，接收值是bool

 li=[11,22,33]

 def foo(arg):
     if arg<22:
         return True
     else:
         return False

 tmp=filter(foo,li)
 print tmp

累加

 li=[11,22,33]

 print reduce(lambda x,y:x+y,li)

 li=[11,22,33]
 y=[1,2,3]
 print zip(li,y)
 [(11, 1), (22, 2), (33, 3)]

强制类型转换，我给的是字符串，但是需要计算8*8的值

 a='8*8'
 b=a.split('*')

 for i in b:
     c=int(i)
     print c,type(c)

a='8*8' print eval(a)#简单版

导入模块的另一种方法，反射，通过字符串的形式导入模块，并以字符串的模式执行函数

 temp='sys'

 mode=__import__(temp)

 print mode.path
 ------------------------------------------//使用以下方法时需要在同一个目录下，貌似不可以跨越文件夹
 temp = ''#模块的名字
 fuc='foo'#函数的名字
 model=__import__(temp)

 a=getattr(model,fuc)#查找该模块中是否有这个函数，函数部分不可以直接写foo
 print a()#获取的是函数，所以需要使用对象

 import random
 #print random.random()#生成0-1之间的随机数
 #print random.randint(1,5)#生成1-5之间的随机数
 print random.randrange(1,3)#1<=x<3

 print chr(random.randint(65,90))#获取随机字母

 生成一个随机的验证码
 import random
 array=[]
 for i in range(6):
     if i==random.randint(1,5):
         array.append(str(i))
     else:
         array.append(chr(random.randint(65,90)))

 print ''.join(array)#Python的格式化操作，拼接字符串，并且用这种方法效率高拼接字符串，并且用这种方法效率高

 MD5加密
 import hashlib
 hash=hashlib.md5()
 hash.update('admin')
 print hash.hexdigest()

序列化与反序列化，pick可以常规类型也可以序列化类，序列化后不可读

 #为什么要序列化？两个python程序内存之间的交互，保存到硬盘上

 import pickle#python与python之间的文件的传输，可以共享文件，相互读
 li=['nima',1,2,3,'',123,4,'']
 dumpsed=pickle.dumps(li)#dumps将所传入的变量的值序列化为一个bytes，然后，就可以将这个bytes写入磁盘或者进行传输。
 print dumpsed
 print type(dumpsed)

 loadsed=pickle.loads(dumpsed)#loads当我们要把对象从磁盘读到内存时，可以先把内容读到一个bytes，然后用loads方法反序列化出对象，也可以直接用load方法直接反序列化一个文件。
 print loadsed
 print type(loadsed)

 pickle.dump(li,open('D:/nima.pk','w'))#dump则更加一步到位，在dump中可以传入两个参数，一个为需要序列化的变量，另一个为需要写入的文件。

 result=pickle.load(open('D:/nima.pk','r'))
 print result

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

 正则表达式
 re模块用于对python的正则表达式的操作。

 字符：

 　　. 匹配除换行符以外的任意字符
 　　\w    匹配字母或数字或下划线或汉字
 　　\s    匹配任意的空白符
 　　\d    匹配数字
 　　\b    匹配单词的开始或结束
 　　^    匹配字符串的开始
 　　$    匹配字符串的结束

 次数：

 　　* 重复零次或更多次
 　　+    重复一次或更多次
 　　?    重复零次或一次
 　　{n}    重复n次
 　　{n,}    重复n次或更多次
 　　{n,m}    重复n到m次

 import re

 hh1=re.match('\d+','123ajfdiosaj12321j4lklnljj432ojoij')#该函数是匹配开头，如果在开头的位置找到就返回找到的值，反之就返回None
 if hh1:
     print hh1.group()
 else:
     print 'nothing'

 hh2=re.search('\d+','ajfdiosaj12321j4lklnljj432ojoij')#该函数是开头开始找，但是它是一直向后找，直到找到了，才返回值
 if hh2:
     print hh2.group()

 ---------------------------------------------------------------------有多少数字取多少数字

 import re
 hh3=re.findall('\d+','aodijfjoj1324joijoij12joi')
 print hh3

 ['', '']
 ---------------------------------------------------------------------先编译，再执行
 import re

 com=re.compile('\d+')
 print com.findall('adfoiqe213324joijoij234')

 ---------------------------------------------------------------------group与groups
 import re

 result=re.search('(\d+)ojoijlo(\d+)','oijoij24324ojoijlo643')
 print result.group()
 print result.groups()

 24324ojoijlo643
 ('', '')

 import time

 #print time.time()
 #print time.strftime('%Y-%m-%d %H:%M:%S')
 #print time.strptime('2014-11-11', '%Y-%m-%d')
 print time.mktime(time.localtime())
 print time.localtime()

 反射器的各种应用
 #!/usr/bin/env python
 #coding:utf-8

 data=raw_input('Please input your address:')
 array=data.split('/')

 username=__import__('backend.'+array[0])#可以实现不同页面之间的跳转，节约代码量

 model=getattr(username,array[0])#将其理解成先进入文件夹
 func=getattr(model,array[1])#然后进入模块调用相应的方法
 func()