修改字符集

全局修改

点击window

针对某一个工程

右键，有一个属性propertes

给某个文件，也就是前面加

也是右键属性，这里就不在说了

#模块的和模块的常用方法

• 至关重要的__init__.py
  如果想导入成模块，一定要有这个文件
• 是否为主文件__name
  if name == '\main__'
  如果不是主文件返回模块文件路径+文件名
• 当前文件 :__doc__
  返回模块级别的注释，函数级别的注释，是在函数下面加6个引号，中间写注释
• __file__:输出当前的路径

  函数式编程

• 参数 def Fun(arg,*args,**kergs)
• 默认参数 print arg
• 可变参数 print *args print **kergs
  一个是列表，一个是字典
• 返回值 return ‘success’

  #!/usr/bin/env python#coding:utf-8def login(username):if username == "alex":    print "登录成功"else:    print "登录失败"if __name__ == "__main__":user = raw_input('username:')login(user)

  yield

print range(10)for item in xrange(10):    print item    #输出的时候并没有全部创建，他只是一个生成器，说明他没有写入内存中    #也就是说每一次创建就只创建一个整数def foo():    yield 1re = foo()print re输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]0123456789
    

def fool():    yield 1    yield 2    yield 3yield 4  #他的执行过程是，第一从从yield 1 执行，下一次直接从yield2开始执行 re = fool()print re#生成了一个生成器，每次遍历只生成一条for item in re :print item结果：
    
     1234
    

def ReadLines():    seek = 0    while True:        with open('E:/temp.txt','r') as f :            f.seek(seek)            date = f.readline()            if date:                seek = f.tell()                yield date            else:                return print ReadLines()for item in ReadLines():    print item

三元运算和lambda表达式

三元运算

• 代码实例:
  result = ‘gt’ if 1>3 else ‘it’
  print result
• Lambda表达式()
  代码实例：
  a = lambda x,y: x+y
  print a(1,2)
• map函数()
  map (lambda x:x*2,range(10))
  意思就是将range的每个值赋给前边

  内置函数

• dir()列出当前文件内置的变量或者方法名，只列出key
• vars()和dir()不一样的是列出key和value
• type() 查看你所创建变量的类型
  a = [] ,本质上是调用一个类，去生成一个列表，本质上是创建了一个类的实例，像tuple就是一个类的名字
• from file import demo
• reload(demo)
  重新导入
• id()
  查看变量的数据
• cmp()函数
  cmp(x,y) 函数用于比较 2 个对象，如果 x< y 返回 -1，如果 x==y 返回 0，如果 x>y 返回 1。
• abs()取绝对值
• bool()将结果换算成布尔值
• divmod()
  计算结果，将商和余数一元组的方式返回
• max([]) 最大值
• min([]) 最小值
• sum([]) 求和
• pow() 指数运算
• len() 计算长度(如果是中文则表示字节的长度)
• all(可迭代的对象) 可迭代对象所有的都为真，则返回Ture，否则返回False
• any(可迭代的对象) 有一个为真则返回Ture
• chr(65) 查看字符
• ord(‘a’) 查看ascall值
• hex() 16进制
• bin() 10进制
• oct() 8进制
• range()
• xrange()
• enumerate(

  for k,v in enumerate([1,2,3,4]):print k,v输出：0 11 22 33 4

  #为程序增加一个序号li = ['手表','汽车','房']for item in enumerate(li,1):print item[0],item[1]#1为初始值1 手表2 汽车3 房

• apply执行函数和函数的调用
  def say():
  print 'say in'
  apply(say)
  输出 ；say in
• map函数() #遍历后面每一个序列的函数
  map (lambda x:x*2,range(10))
  意思就是将range的每个值赋给前边(可以是函数)

  lala = [];def foo(arg):return arg + 100li = [11,22,33]lala = map(foo,li)print lala结果：[111, 122, 133]#也可以使用 lala.append(item+100)temp = map (lambda arg:arg+100,li)

• filter函数 #条件为真，将其加入序列中

  temp = []li = [11,22,33]def foo(arg):if arg <22:    return Trueelse:    return Falsetemp = filter(foo,li)print temp将li序列中满足条件的返回temp序列中结果：11

• reduce 累加(只能两个参数)

  print reduce(lambda x,y:x+y,[1,2,3] )结果 6将前一次的计算结果，传递为第二次计算的第一个参数

• zip 函数 #将列表中的第一个组成新的列表
  x = [1,2,3]
  y = [4,5,6]
  z = [4,5,6]
  print zip(x,y,z)
  结果：
  [(1, 4, 4), (2, 5, 5), (3, 6, 6)]
  
• eval函数 #直接计算字符串类型的运算

  a ='8*8'print eval(a)结果：64

  字符串的格式化

  s = 'i am {0},{1}'

  print s.format('alex','xxx')
  i am alex,xxx

  反射 通过字符串的形式导入模块，并以字符串的形式执行函数 (动态切换数据库连接)

  不允许使用import os 导入，用temp的方法导入

  temp = 'os'model = __import__(temp)print modelprint model.path输出：
        
         
        

  

  getattr就是在mysqlhelper模块中查找count函数
  Function就等于调用的count函数
  相应的有delattr()、hasattr()判断函数中是否含有相应的模块

#使用random生成验证码

它使用的是ascall的值进行生成的

import randomprint random.random()print random.randint(1,5)#生成1-5之间的随机整数print random.randrange(1,3)#生成大于等于1，小于3的随机数

import randomcode = []for i in range(6):    if i == random.randint(1,5):        code.append(str(random.randint(1,5)))    else:        temp = random.randint(65,90)        code.append(chr(temp))print ''.join(code)

#注意：join和+=的区别

join效率更高，+=每次都要在内存中请求一块空间，join只申请一次

md5加密

#!/usr/bin/env python#coding:utf-8import hashlibhash=hashlib.md5()hash.update('admin')print hash.hexdigest()print hash.digest()21232f297a57a5a743894a0e4a801fc3!#/)zW��C�JJ�¬�#md5不能反解

序列化和JSON

应用实例：(python 和python之间传输文件，单机游戏实时保存)

为什么要序列化？

一个程序将列表存在一个程序中，另一个程序使用这个文件的时候。使用序列化之后在让另一个程序去读取的话，使两个python程序之间内存数据之间的交换，两个独立的进程在内存中看，他们的内存空间不能互相访问，如果两个程序之间不仅仅只是简单的列表共享，还想其他数据交换，数据可能比较复杂。而且硬盘只能存字符串类型的数据，只能通过系列化，存入文件，另一个程序然后读取文件的内容，然后将其反序列化之后，在加载到内存中

序列化:把一个对象或(一个列表、字典)，把对象通过Python特有的机制序列化，序列化就是以特殊的形式以过二进制的方式给对象加密，并且序列化之后可以反序列化。

序列化

import pickleli = ['axex',11,22,'ok','sb']print pickle.dumps(li)print type(pickle.dumps(li))输出结果：(lp0S'axex'p1aI11aI22aS'ok'p2aS'sb'p3a.
    
     #是一个没有规则的字符串类型
    

反序列化

import pickleli = ['axex',11,22,'ok','sb']dumpsed = pickle.dumps(li)print type(dumpsed)loadsed = pickle.loads(dumpsed)print loadsedprint type(loadsed)
    
     ['axex', 11, 22, 'ok', 'sb']
     
    

将列表序列化到一个文件中

import pickleli = ['axex',11,22,'ok','sb']pickle.dump(li,open('E:/temp.pk','w'))result = pickle.load(open('E:/temp.pk','r'))#将文件中反序列化

JSON:一种标准化的数据格式，把不同格式的数据JSON化。

##两种序列化的区别

• pickle只能在python中使用
• JSON是所有的语言都支持的接口
• pickle 不但可以dump常规的数据类型，比如，字典、列表、集合，还可以序列化类、对象，基本上所有的类型都可以实现序列化，JSON只能序列化常规的数据类型。因为，在不同的语言中类的格式不同。
• pickle 序列化的序列的数据不可读，但是JSON的数据格式是用人眼可以看出来他的格式

  import jsonname_dic = {'name':'wupeiqi','age':23}print json.dumps(name_dic)输出结果：全部变成字符串{"age": 23, "name": "wupeiqi"}

  

  为什么多个了U呢，因为在存入内存中使用Unicode，你本事是utf-8，然后反序列化之后又变成Unicode