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':'18'}

foo(**a)

以列表形式存储

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


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

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' 2 print eval(a)#简单版 

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

temp='sys'

mode=__import__(temp)

print mode.path
------------------------------------------//使用以下方法时需要在同一个目录下，貌似不可以跨越文件夹
temp = '12'#模块的名字
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,'2432',123,4,'1']
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    匹配数字
　　    匹配单词的开始或结束
　　^    匹配字符串的开始
　　$    匹配字符串的结束

次数：

　　* 重复零次或更多次
　　+    重复一次或更多次
　　?    重复零次或一次
　　{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

['1324', '12']    
---------------------------------------------------------------------先编译，再执行
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
('24324', '643')

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()