python自学笔记

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提供的类,可以看看

Image基本功能 

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小游戏

 

 

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值