https://www.cnblogs.com/secondtonone1/p/6796323.html
python自学笔记(一)
我没学过python，通过网上和一些图书资料，自学并且记下笔记。
很多细节留作以后自己做项目时再研究，这样能更高效一些。
python基础自学笔记
一、基本输入和输出
pthon3.0用input提示用户输入，用print提示用户输出，格式为print("...")
如果格式化输出，那么格式为print("%d" %(变量名)), %d可以替换为%s等其他格式符，
以后用到什么格式自己查，这样学起来高效。
简单的例子：
#-*-coding:utf-8-*-
name = input("What's your name ? >")
age = input("How old are you ? >")
print ("your name is %s, your age is %d" %(name, int(age)))
print ("你的名字是 %s, 你的年龄是 %d" %(name,int(age)))
运行结果：
二、基本数据结构
1 列表
列表和C++里边的list差不多
插入方式为: list.insert(1,‘小草’);
1为要插入元素放在下标为1的位置，‘小草’为要插入的元素
移除元素的方式为：list.pop(3);
指定取出下标为3的元素
list中元素是按照从下标为0开始计算的。
如果要计算列表中元素个数可以通过len(list)计算。
下面是个小例子：
animals = ["大象","猴子","蚂蚁","豪猪"]
print ("动物园有这些动物:", animals)
lion = "狮子"
print ("新来了", lion)
animals.insert(1,lion)
print ("动物园有这些动物:", animals)
animals.pop(3)
print ("蚂蚁灭绝了")
print ("动物园有这些动物:", animals)
print ("老虎和狮子交配生了两个小宝宝")
babies = ["小宝宝1号", "小宝宝2号"]
animals.insert(2,babies);
print ("动物园有这些动物:", animals)
print("饲养员给两个小宝宝取了名字")
animals[2][0]="小毛"
animals[2][1]="大毛"
print ("动物园有这些动物:",animals)
print("列表中有%d个元素" %len(animals))
print("第三个元素包含%d个元素" %len(animals[2]))
试着用python 运行上面这个程序
2 tuple（元组）
tuple定义之后不可修改，理解为不可修改的列表就行了
试着运行下面这个程序，看看结果：
#-*-coding:utf-8-*-
nums = (0,1)
print("nums are", nums)
another = (0,1,[3,4])
print("nums are", another)
another[2][0] = 5
print("nums are", another);
为什么another能被修改？因为another[2]指向的是list，接着将list的第一个元素，
下表为0的元素赋值为5，这是允许的。
3 dict（字典）
字典和C++map很相似，但是不完全相同，字典dict可以包含不同类型的key和value
字典的插入方式很简单d['韩梅梅']=23
d为字典定义的变量名，key为‘韩梅梅’, value为23
当字典d中没有‘韩梅梅’这个key，那么就会将key和value插入d
如果调用d[‘韩梅梅’]=22，那么‘韩梅梅’对应的value就为22了
如果字典d中没有‘李磊’这个key，那么调用print(d['李磊'])就会提示出错。
所以取元素的时候要记得判断字典中是否有该key对应的value
可以通过get和in判断，下边代码有使用方法。
字典同样调用pop移除元素
d.pop('韩梅梅')
下面这段代码综合了dict使用方式
infos = {"李明":23, "豆豆":22,"老李":55}
print("李明的年龄为%d" %(infos["李明"]))
infos["王立冬"]=32
print (infos)
#print (infos["梁田"])
if not ("梁田" in infos):
print("梁田不在记录")
print(infos.get("梁田"))
print(infos.get("梁田","梁田不在记录"))
infos.pop("王立冬")
print (infos)
用python调用上边代码，看看效果。
4 set（集合）
集合中允许存在多个重复的值
集合添加元素用add，删除用remove操作
下边的代码为集合操作
numset = set([1,3,5,7,9]) print(numset) numset.add(4) print(numset) numset.add(4) print(numset) numset.remove(3) print(numset) numset2 = set([2,4,6,8,10]) print(numset&numset2) print(numset|numset2)
三、循环和控制
这部分和C++差不多，就是基本写法不一样
nums = (0,100,34,50,179,130,27,22)
print("nums are:", nums)
bigernums =[]
smallnums = []
for num in nums:
if num > 50:
bigernums.append(num)
print("大于50的数字有:", bigernums)
for num in nums:
if num < 50:
smallnums.append(num)
print("小于50的数字有:", smallnums)
print(range(5))
print(list(range(5)))
#1~10数字求和
sum = 0
for num in list(range(11)):
sum += num
print("1到10数字求和结果为:%d" %sum)
#错误输出
#print("1到10数字求和结果为:%d", sum)
#换一种方式求和,while循环注意别写成死循环
i = 0
sum = 0
while i < 11:
sum += i
i=i+1#i++不行，习惯了C++
print("1到10数字求和结果为:%d" %sum)
python通过缩进和：控制模块。
四、函数
1 定义函数
#函数的定义
def judgeint(x):
if not isinstance(x,(int)):
raise TypeError('类型不匹配')
else:
return x
是通过def 函数名(参数):方式来定义函数。上面这个函数定义在func.py文件中，
我再写一个文件使用这个函数
from func import judgeint
numlist = [1,3,5]
strlist =['1','2','3']
for i in numlist:
print(judgeint(i))
for j in strlist:
print(strlist(j))
结果为：
可见strlist中字符串类型被函数识别并终止程序运行了。
想用到某个.py文件的函数可以用
from 文件名(不包含.py) import 函数名
如果想用文件中所有的接口
from 文件名(不包含.py) import *
其他的引用方式我也不会，以后遇到了再去查。
也可以去写一个空函数
#空函数
def emptyfun(x):
pass
pass表示什么都不做。
当然函数可以返回许多值，这些值其实是通过tuple返回的
定义函数
#多个返回值
def getposition(x,y):
return x, y
调用这个函数
from func import *
num1 = 0; num2 = 0
num1, num2 = getposition(1,3)
print('num1 is %d, num2 is %d' %(num1,num2))
print('result is: ', getposition(1,3) )
结果为：
2 函数参数分类和使用
1 位置参数
位置参数是普通的参数
如下：
def power(x):
return x*x
2 默认参数
默认参数提供了参数的默认赋值
#默认参数
def power(x,n = 2):
imul =1
while(n > 0):
imul = x*imul
n = n-1
return imul
值得注意的是默认参数要指向不可变对象，否则函数重复调用默认参数会被修改
def getList(L=[]):
L.append("end")
return L
重复调用看看结果如何：
#-*-coding:utf-8-*- from func import * L=[] print(getList(L)) print(getList(L))
结果
可以看出默认参数随着函数调用被修改了，所以尽量不要让默认参数指向可变对象，
list就是可变对象。
3 可变参数
可变参数使用和定义都非常方便
定义：
def calsum(*nums):
sum = 0
for i in nums:
sum = sum+ i
return sum
使用：
#-*-coding:utf-8-*- from func import * L=[1,3,5,7,9] print(calsum(*L)) print(calsum(*range(0,101)))
定义可变参数前边加*,使用时可以传入list，tuple等，实参前也加*即可。
4 关键字参数
其实和可变参数类似，关键字参数可以直接传入字典
定义：
def getinfo2(name, age, **info):
print("姓名：", name, "年龄：", age, "其他信息:", info)
def getinfo3(name,age,**info):
if 'city' in info:
print("有城市信息")
if 'job' in info:
print("有工作记录")
print("姓名：", name, "年龄：", age, "其他信息:", info)
定义关键字参数在形参前边加**
使用：在实参前加**表示取出字典中所有内容依次传递给函数
from func import *
info ={'性别':'女','job':'学生','city':'上海'}
info2 ={'性别':'男','job':'工人','city':'北京'}
getinfo2('韩梅梅', 23, **info)
getinfo3('李雷',25,**info2)
结果
5 命名关键字参数
命名关键字参数就是传入命名的关键字，如指定传入的关键字参数的key为‘city’，‘type’等等。
举例：
def getinfo8(name, age, *,city, job):
print("姓名：", name, "年龄：", age, "城市:", city, "工作：", job)
def getinfo7(name, age, *infolist, city, job):
print("姓名：", name, "年龄：", age, "城市:", city, "工作：", job, "其他信息:", infolist)
可以看出命名关键字参数格式为(*,指定名称1，指定名称2...)的格式
当明明关键字参数之前的参数为可变参数时，那么不需要*，只需指明指定的几个名成即可
格式为:(*可变参数,指定名称1,指定名称2...)
试着写个代码用一下：
from func import *
info ={'性别':'女','job':'学生','city':'上海'}
info2 ={'性别':'男','job':'工人','city':'北京'}
getinfo2('韩梅梅', 23, **info)
getinfo3('李雷',25,**info2)
getinfo8('王麻子',70, city ='南京', job = '裁缝')
infolist = ['有犯罪记录','酗酒']
getinfo7('张三',50,*infolist,city ='翰林',job ='无业游民')
读者自己打印下，看看结果
当然命名关键字参数可以提供默认值
def getinfo4(name, age,*,city='沈阳',job):
print("姓名：", name, "年龄：", age, "城市:", city, "工作：", job)
6 参数混合使用
当参数列表包含位置参数，默认参数，可变参数，关键字参数和明明关键字参数时，
从左到右的顺序为
位置参数，默认参数，可变参数，命名关键字参数，关键字参数
读者可以自己考虑下为什么这么规定
下面定义两个函数：
def getinfo5(name,age,city='沈阳',**info):
print("姓名：", name, "年龄：", age, "城市:", city, "其他信息:", info)
def getinfo6(name,age,city='沈阳',*infolist ,health = '良好', job,**otherinfo):
print("姓名：", name, "年龄：", age, "城市:", city, '工作信息：',job,'\n',
"身体状况", health, "个人备注",infolist,'\n',
"其他信息:", otherinfo)
使用这一系列定义的函数
info5 ={'性别':'男','job':'工人','兴趣':'修自行车'}
baselist=('Linkn',28,'上海','喜欢喝冰啤酒','爱打麻将')
getinfo6(*baselist,**info5)
getinfo5('Linkn',28,'上海',**info5);
函数调用传入实参都可以通过*arg,**dict格式，提高了开发效率
7 递归函数
递归函数和C++一样，先实现一个阶乘的函数
#递归计算阶乘函数
def imul2(num=1):
if num ==1:
return num
else:
return num * imul2(num-1)
print(imul2(3)) 看看结果
同样去实现汉诺塔
编写move(n, a, b, c)函数，它接收参数n，表示3个柱子A、B、C中第1个柱子A的盘子数量，
然后打印出把所有盘子从A借助B移动到C的方法，计算n==3时，移动方法
读者试着自己完成，我是这样实现的
def move(n,A,B,C):
if n==1:
print("%s --> %s" %(A,C))
return
else:
move(n-1,A,C,B)
move(1,A,B,C)
move(n-1,B,A,C)
调用
move(3,'A','B','C')
结果为
用递归很简单实现了复杂的逻辑，但是递归有一个问题就是当递归次数过大容易造成栈溢出。
基础先记到这里，下一篇会记录python的特性和函数编程。
python自学笔记(二)
https://www.cnblogs.com/secondtonone1/p/6813266.html
通过前文介绍，大体上可以用学过的知识做一些东西了。
这里简单介绍下python参数解析argparse命令。
使用argparse需要引用
import argparse
然后调用
parser = argparse.ArgumentParser()
ArgumentParser()函数可以传一些参数
parser = argparse.ArgumentParser(description='This is a PyMOTW sample program')
参数有很多种类型，读者自己查阅，参考资料的链接：
https://blog.ixxoo.me/argparse.html
接下来添加参数
parser.add_argument('file')
parser.add_argument('-o', '--output')
添加参数 -表示可选参数,用于一个字符，表示缩写
--也是可选参数，用于两个或以上的字符
最后是参数解析
parser.parse_args(['-o', 'output.txt'])
parse_args()运行时，会用'-'来认证可选参数，剩下的即为位置参数。
位置参数不可缺少，可选参数可提供默认值
如果python程序运行，parse_args()会依次处理传入参数，
第一个参数为该python程序的文件名，其余的依次为传入参数。
这些文字看不懂不要紧，试着看看下边的程序和运行结果
#-*-coding:utf-8-*-
import argparse
#命令行输入参数处理
parser = argparse.ArgumentParser()
parser.add_argument('file') #输入文件
parser.add_argument('-o', '--output') #输出文件
parser.add_argument('--width', type = int, default = 50) #输出字符画宽
parser.add_argument('--height', type = int, default = 30) #输出字符画高
#获取参数
args = parser.parse_args()
IMG = args.file
WIDTH = args.width
HEIGHT = args.height
OUTPUT = args.output
print("IMG is %s" %(IMG))
print("WIDTH is %d" %(WIDTH))
print("HEIGHT is %d" %(HEIGHT))
print("OUTPUT is %s" %(OUTPUT))
这个程序就是解析命令行参数，然后将输入的参数打印出来
如果不输入参数直接python test.py 试试？
提示缺少位置参数file
试试python test.py test.png
四个命令行参数打印出来了
--height 可选参数为默认值30
--width 可选参数为默认值50
file 位置参数为test.png
-o 为--output的缩写为None，因为没提供默认值。我也没输入-o参数
所以为None
输入python test.py test.png --width 30 -- height 50 -o output.txt
用全称--output录入也可以
python test.py test.png --width 30 -- height 50 --output output.txt
这个过了就可以往下做了，下面安装PIL库，PIL为python处理图形图像的基本库
windows安装的方式为：
http://jingyan.baidu.com/article/ff42efa929e6c8c19f220254.html
Linux安装方式为：
下面编写图片转字符画程序：
将文件命名为print.py
1 包含库和函数，定义基本的字符序列
from PIL import Image
import argparse
#命令行输入参数处理
parser = argparse.ArgumentParser()
parser.add_argument('file') #输入文件
parser.add_argument('-o', '--output') #输出文件
parser.add_argument('--width', type = int, default = 50) #输出字符画宽
parser.add_argument('--height', type = int, default = 30) #输出字符画高
#获取参数
args = parser.parse_args()
IMG = args.file
WIDTH = args.width
HEIGHT = args.height
OUTPUT = args.output
ascii_char = list("$@B%8&WM#*oahkbdpqwmZO0QLCJUYXzcvunxrjft/\|()1{}[]?-_+~<>i!lI;:,\"^`'. ")
2 编写转换函数
# 将256灰度映射到70个字符上
def get_char(r,g,b,alpha = 256):
if alpha == 0:
return ' '
length = len(ascii_char)
gray = int(0.2126 * r + 0.7152 * g + 0.0722 * b)
unit = (256.0 + 1)/length
return ascii_char[int(gray/unit)]
0.2126 * r + 0.7152 * g + 0.0722 * b为官方提供的
灰度计算公式，unit表示一个单元占多少灰度，
gray/unit可以找到对应的单元，从而转换为字符。
3调用get_char完成转换
if __name__ == '__main__':
im = Image.open(IMG)
im = im.resize((WIDTH,HEIGHT), Image.NEAREST)
txt = ""
for i in range(HEIGHT):
for j in range(WIDTH):
txt += get_char(*im.getpixel((j,i)))
txt += '\n'
print (txt)
#字符画输出到文件
if OUTPUT:
with open(OUTPUT,'w') as f:
f.write(txt)
else:
with open("output.txt",'w') as f:
f.write(txt)
Image为PIL提供的类，可以看看
im.getpixel((j,i)) 通过传入横纵坐标，返回tuple
tuple中数据依次为r,g,b,alpha
之前讲过可以通过*() 或*[]实现逐个元素传入。
get_char(*im.getpixel((j,i)))将参数传入返回字符。
之后分别将字符打印出来，并写入文件。
源码下载地址： python图片转字符画
效果如下：
https://www.cnblogs.com/secondtonone1/p/6892928.html
python学习笔记(三)高级特性
一、切片
list、tuple常常截取某一段元素，截取某一段元素的操作很常用 ，所以python提供了切片功能。
L=['a','b','c','d','e','f'] #取索引0，到索引3的元素，不包括索引3 print(L[0:3]) #开始索引为0可以省略 print(L[:3]) #下标1到3 print(L[1:3]) #取最后一个元素 print(L[-1]) #取倒数后两个元素 print(L[-2:]) #取前四个数，每两个取一个 print(L[:4:2]) #所有数，每两个取一个 print(L[::2])
二、迭代
除了list、tuple可以迭代外，python中的dict类型变量也可以迭代。
dictor = {'name':'Jul','age':17,'femail':1}
#迭代key
for key in dictor:
print(key)
#迭代value
for value in dictor.values():
print(value)
#迭代key,value
for k,v in dictor.items():
print(k,v)
可以将list变为索引元素对的形式
for x,y in [(1,2),(3,4),(5,6)]:
print(x,y)
#变为索引元素对
for i,value in enumerate(['A','B','C']):
print(i,value)
同时可以判断一个对象是否可以迭代
for x,y in [(1,2),(3,4),(5,6)]:
print(x,y)
#变为索引元素对
for i,value in enumerate(['A','B','C']):
print(i,value)
三、列表生成式
list函数可以将一组对象组合为列表，[]操作也可以。[]操作的方式称作列表生成式
print([x for x in range(1,11)]) print(list(range(1,11)))
在列表生成式中可以加入一些运算规则，使生成的列表具备运算规则。
#变为索引元素对
for i,value in enumerate(['A','B','C']):
print(i,value)
#平方
print([x*x for x in range(1,11)])
#偶数平方
print([x*x for x in range(1,11) if x%2 ])
#k:v形式的列表
strdic={'a':'a1','b':'b1','c':'c1'}
print([k+':'+v for k,v in strdic.items()])
#将列表中字符串换为小写
L = ['Hello', 'World', 18, 'Apple', None]
print([s.lower() for s in L if(isinstance(s,str)) ])
四、生成器
python提供生成器的功能，生成器根据函数或运算规则产生一系列数据，
通过对返回值g调用next(g)可以依次取出生成的数据。
g = (x*2 for x in range(1,11)) print(g) print(next(g))
可以一直调用next(g)，直到产生StopIteration异常。
当然也可以通过函数构造生成器，将函数return的关键字换为yield即可。
#菲波那切数列
def fib(max):
a,b,n = 0,1,0
while n < max:
yield b
a,b=b,a+b
n = n+ 1
return "exit"
通过下面方式next取出数列中的元素，第三次调用会抛出StopIteration异常。
g=fib(2) print(g) print(next(g)) print(next(g)) #print(next(g))
上面代码中g为迭代器，通过对g不断调用next取出数列中元素。
可以通过检测异常的方式完成遍历，避免程序崩溃。
g2 = fib(6)
while True:
try:
value = next(g2)
print("value: ", value)
except StopIteration as e:
print("Generator return value is: ", e)
break
可以用生成器实现杨辉三角，生成器函数为triangles()。
生成器函数triangles()实现如下：
def triangles():
yield [1]
yield [1,1]
lists = [1,1]
while True:
i = 1
n = len(lists)
newlists = [1]
while i < n:
newlists.append(lists[i-1] + lists[i])
i = i+1
newlists.append(1)
lists = newlists
yield newlists
五、迭代器
python提供生成器的功能，生成器根据函数或运算规则产生一系列数据，
通过对返回值g调用next(g)可以依次取出生成的数据。g就是迭代器。
有的对象可以迭代但是不是迭代器，只有可以被next调用的对象才是迭代器。
同样可以通过isinstance函数判断迭代器。
from collections import Iterable
from collections import Iterator
b1 = isinstance([], Iterable)
b2 = isinstance([], Iterator)
print('[] is Iteralbe', b1)
print('[] is Iterator', b2)
b1 = isinstance({},Iterable)
b2 = isinstance({},Iterator)
print('[] is Iteralbe', b1)
print('[] is Iterator', b2)
b1 = isinstance((x*x for x in range(10)), Iterable)
b2 = isinstance((x*x for x in range(10)), Iterator)
print('x*x for x in range(10) isIterable', b1)
print('x*x for x in range(10) isIterator', b2)
#可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator
b1 = isinstance(triangles(),Iterable)
b2 = isinstance(triangles(),Iterator)
print('triangles()', b1)
print('triangles()', b2)
特性就总结到此，下次会总结记录python函数的一些特性。
https://www.cnblogs.com/secondtonone1/p/6903191.html
python学习笔记(四) 思考和准备
一、zip的坑
zip()函数接收多个可迭代数列，将数列中的元素重新组合，在3.0中返回迭代器指向
数列首地址，在3.0以下版本返回List类型的列表数列。我用的是3.5版本python，
所以zip返回的是指向地址。
先看几个例子
结果：
可见，在3.0以上版本，对zip函数返回的结果采用list函数可以转化为列表。
通过列表生成式同样可以将zip结果化为列表。
结果：
当zip操作的对象为一个列表，那么生成的列表中每个元素(元祖)中
为(n,)形式。
当zip操作的多个列表长度不一样，那么zip返回生成的列表中元素个数
为最短列表长度。
结果为：
list函数可以将一个元祖转化为列表。下面可以将zip返回的数据转化为
我们方便操作的列表元素.
结果：
这样将zip函数返回的数据通过list和迭代，生成了二维List，方便以后操作。
下边这段代码在3.0版本以上和3.0版本以下会有不同结果。
2.7版本结果：
3.0版本结果
之前提起过zip在3.0以上版本返回迭代器指向内存地址。3.0以下
版本返回的为列表，所以在3.0版本一下输出是符合最初目的。
但是3.0版本python最后一行输出却为空列表[]。
这个原因主要是迭代器在被循环迭代或者访问后，会自动
移动指针，指向下一个要迭代的元素。这和C++是不同的，
C++/C语言需要用户自己控制迭代器移位。
那么肯定有人会说第一句和第三句打印的list1的值相同，
是不是list1迭代器指向的空间没有移动呢？
不是的，只要list1被循环迭代，内部指向空间的地址就会变化，
只是调用print打印list1时，python只返回迭代器指向空间的首地址，
而不会告诉具体指向的地址空间。
修改下代码，看看是不是上文所述那样：
结果：
可见，输出list1指向地址内容的时候出现StopIteration异常，
这个异常前几篇介绍过，是因为迭代器已经指向空间的末尾了，
再调用就会出现该异常，所以对于迭代器当遍历迭代后一定要注意
迭代器指向地址变化的问题。
二、迭代器的坑
迭代器的问题就在于被迭代使用后，内部指向的地址空间变化了，
但是打印迭代器，返回的认为迭代器最初指向的内存空间首地址。
结果：
每次打印g返回结果都一样，但是g指向的位置确实变了。
说实话，这种隐藏性的问题应该让别人知道。
三、矩阵的转置和左右逆置
通过zip函数可以实现矩阵的转置和逆置，
将矩阵按照每一行存储在一个list中，这些list再组合成一个大的list，构成二维list表示矩阵。
矩阵的转置：
下边的例子可以看效果：
结果：
同样的道理，矩阵的左右逆置
结果：
四、format函数介绍
format函数通过{}替代%，实现字符串的动态匹配。
结果：
五、defaultdict函数介绍
实现一个统计字符串个数的功能。
strings = ('puppy', 'kitten', 'puppy', 'puppy',
'weasel', 'puppy', 'kitten', 'puppy')
如果用下边的代码实现统计功能
当counts中不存在某个单词，第一次调用counts[kw]+=1会提示报错。
所以有几种方式实现该功能。
这种方式先判断counts中是否含有关键字，没有就先赋值。
这种方式通过设置counts中关键字对应的默认值，当counts中不存在某个关键字，
那么该关键字对应的value为0，然后该值+1，表示第一次统计。
如果counts中存在该关键字，那么就不执行setdefault函数，关键字对应的value值加1。
这种方式引用了collections的defaultdict，difaultdict接收一个函数，该函数
返回dict中元素的默认值。
六、any函数介绍
any函数接收一个可迭代对象，一般为list或者tuple，list或者tuple中有一个
元素满足条件any函数就返回true，当所有元素都不满足条件，any返回false
结果：
https://www.cnblogs.com/secondtonone1/p/6907195.html
python学习笔记(五) 200行实现2048小游戏
用前文提到的基础知识，和网上流行的2048源码，用python实现该游戏。
先将用户操作和游戏逻辑绑定。
WASD分别对应移动方向上、左、下、右
然后实现矩阵的转置和逆置，这样只要实现一个方向的移动，通过转置和逆置就可以得到其他方向
的移动。
基本的函数声明完成了，下面定义GameField类，主要实现游戏逻辑和状态转换。
GameField类和其中包含的一些函数。先看构造函数。
构造棋盘并且刷新棋盘，作为初次游戏的布局。
spawn函数为随机某个位置设置随机值。
移动函数，这个函数比较复杂，代码也比较多。
move函数内部先定义了左移的函数move_row_left，move_row_left内部定义了tighten和merge函数。
tighten函数作用是先将一行中非0的元素移动到左边排列，剩余的0元素放在右边，可以理解为压缩。
如[0,2,2,4]经过tighten调用后就变为[2,2,4,0]。merge函数的功能是将相邻的相等的元素进行合并，
比如[2,2,8,0]经过merge后变为[0,4,8,0]，[0,4,8,0]经过再次tighten调用后变为[4,8,0,0]
所以move_row_left内部实现的就是先对一个队列tighten，然后merge再次tighten达到左侧都是非0，右侧都是0。
move函数最后定义了一个dict，dict的key为方向，value为二维list。这个二维list是通过lambda表达式调用
左移函数以及矩阵逆置和转置等操作生成的。
举例说明右移：通过右移要达到的效果是[2,2,4,4]=>[0,0,4,8]，为达到该目的，通过逆置矩阵，左移，再次逆置矩阵即可。
先逆转矩阵
[2,2,4,4]=>[4,4,2,2]
再执行左移函数
[4,4,2,2]=>[8,4,0,0]
再执行矩阵逆置
[8,4,0,0]=>[0,0,4,8]达到最初效果
上移和下移都是类似。
move函数最后通过判断传入direction是否符合标准，如果符合再次判断元素是否可以移动，如果可以移动则取出dict中方向key对应
的value，即二维list，从而得出移动后的棋盘界面。如果所有元素都不能移动，那么判断失败。
判断某个方向是否有元素可以移动，定义了如下函数。
同样是先判断是否可以左移，其他方向能否移动可以通过左移操作和矩阵的转置，逆置判断。
row_is_left_movable是判断是否可以左移操作的函数，内部定义了change函数，
change函数的功能为判断有左右相邻元素可以合并，或者该行有含有0的元素，则返回true，表示该行可以左移。
反之为不可左移，返回false。any函数判断该行所有元素，如果都没有可移动的元素，返回false。
同样是通过check这个dict，结合逆转和转置判断其他方向是否可以移动。如果某个方向所有行都不能移动，
表示矩阵中所有元素不能按照该方向移动了。
下面是判断输赢的函数。
到此为止GameField类介绍完了，下面是main函数。
定义了几个状态，通过状态机的方式运行游戏。 curses.wrapper模块。这个函数做了一些初始化的工作，包括上面提到的和颜色的初始化。
然后再执行main函数，最后重置。
源码下载地址：
http://download.csdn.net/detail/secondtonone1/9852914
运行上述代码效果如下：
我的公众号，谢谢关注
这是后一篇制作2048游戏的准备，下一篇制作2048小游戏
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
