游戏中的角色移动：闭包（closure）在实际开发中的作用

neptune10000

实践不错～～

失落de天才

往上走为何会返回，不应该一直在最上嘛

tjjggyh

def create(post_x = 0, post_y = 0):
    def moving(direction, step):
        nonlocal post_x, post_y
        new_x = post_x + direction[0]*step
        new_y = post_y + direction[1]*step
        if new_x > 100:
            post_x = 200 - new_x
        elif new_x < -100:
            post_x = -200 - new_x
        else:
            post_x = new_x
            
        if new_y > 100:
            post_y = 200 - new_y
        elif new_y < -100:
            post_y = -200 - new_y
        else:
            post_y = new_y
            
        return post_x , post_y
    return moving

move = create()
print ('向右移动10步后。位置是：', move([1,0], 10) )
print ('向上移动130步后。位置是：', move([0,1], 130) )

tjjggyh

def create(post_x = 0, post_y = 0):
    def moving(direction, step):
        nonlocal post_x, post_y
        new_x = post_x + direction[0]*step
        new_y = post_y + direction[1]*step
        if new_x > 100:
            post_x = 200 - new_x
        elif new_x < -100:
            post_x = -200 - new_x
        else:
            post_x = new_x
            
        if new_y > 100:
            post_y = 200 - new_y
        elif new_y < -100:
            post_y = -200 - new_y
        else:
            post_y = new_y
            
        return post_x , post_y
    return moving

move = create()
print ('向右移动10步后。位置是：', move([1,0], 10) )
print ('向上移动130步后。位置是：', move([0,1], 130) )
print ('向左移动10步后。位置是：', move([-1,0], 10) )

genlshe

origin = (0, 0)  # 原点
legal_x = [-100, 100]  # x轴的移动范围
legal_y = [-100, 100]  # y轴的移动范围


def create(pos_x=0, pos_y=0):
    # 初始化位于原点为主
    def moving(direction, step):
        # direction参数设置方向，1为向右（向上），-1为向左（向下），0为不移动
        # step参数设置移动的距离
        nonlocal pos_x, pos_y
        pos_x = 0
        pos_y = 0
        new_x = pos_x + direction[0] * step
        new_y = pos_y + direction[1] * step
        # 检查移动后是否超出x轴边界
        #当移动到边界后，掉头往回走，如果再次碰到另一边界，再次掉头，在移动范围内做往返运动
        while True:
            if    new_x < legal_x[0]:
                  new_x = legal_x[0] - (new_x - legal_x[0])
            elif new_x > legal_x[1]:
                  new_x = legal_x[1] - (new_x - legal_x[1])
            else:
                  pos_x = new_x
                  break
        # 检查移动后是否超出y轴边界
        if new_y < legal_y[0]:
            pos_y = legal_y[0] - (new_y - legal_y[0])
        elif new_y > legal_y[1]:
            pos_y = legal_y[1] - (new_y - legal_y[1])
        else:
            pos_y = new_y
        return pos_x, pos_y

    return moving


move = create()
print('向右移动10步后，位置是：', move([1, 0], 430))
print('向上移动130步后，位置是：', move([0, 1], 430))
print('向左移动10步后，位置是：', move([-1, 0], 10))

chenyingy

哭辽看不懂

a7384657

看懂了哈哈

qushuo

。。。

1404461012

guokai83524 发表于 2014-3-17 13:05
看不懂最后的调用30-33行，为什么move里面可以这样带参数，不理解

试着把30行和31行写成一行试试，你应该就会了

Kid.A

python引用变量的顺序： 当前作用域局部变量->外层作用域变量->当前模块中的全局变量->python内置变量 。

Kid.A

我的理解是:nonlocal比较像c语言中的static--局部静态变量，出函数后现有的值不释放

天秤阿星

1

zxxbc

def moving(direction, step):,这一句里面，direction定义了么？

chriszt

刚开始学小甲鱼的Python，我也实现一个版本，和小甲鱼的版本略有不同，请大家指点：
def create(posX = 0, posY = 0):
# 用户的起始位置，默认在坐标原点(0, 0)
# @posX: X轴的起始位置
# @posY: Y轴的起始位置
    def moving(direction, step):
    # 用户移动的方向和步长
    # @direction: 1表示向上（向右），-1表示向下（向左）
    # @step: 移动的步长
        nonlocal posX, posY

        # 用户移动后的位置
        newPosX = posX + direction[0] * step
        newPosY = posY + direction[1] * step

        # 判断时候超出Ｘ轴的边界，若超出边界，则从另一侧进入区域
        if newPosX < legalX[0]:
            posX = legalX[1] - (legalX[0] - newPosX) + 1
        elif newPosX > legalX[1]:
            posX = legalX[0] - (legalX[1] - newPosX) - 1
        else:
            posX = newPosX

        # 判断时候超出Y轴的边界，若超出边界，则从另一侧进入区域
        if newPosY < legalY[0]:
            posY = legalY[1] - (legalY[0] - newPosY) + 1
        elif newPosY > legalY[1]:
            posY = legalY[0] - (legalY[1] - newPosY) - 1
        else:
            posY = newPosY
        return posX, posY
    return moving

########### 全局区域 ##############
# 地图范围
legalX = [-100, 100]
legalY = [-100, 100]

# 用户１的移动轨迹
user1 = create()
print("[用户１]出现在坐标原点", (0, 0))
print("  向左走10步：", user1([1, 0], 10))
print("  向上走30步：", user1([0, 1], 30))
print("  向下走40步：", user1([0, -1], 40))
print("  向左走111步：", user1([-1, 0], 111))

# 用户2的移动轨迹
user2 = create(-100, -100)
print("[用户2]出现在左下角", (-100, -100))
print("  向左下走1步：", user2([-1, -1], 1))
print("  向左下走100步：", user2([-1, -1], 100))
print("  向左上走50步：", user2([-1, 1], 50))

zhjshi40

假装看得懂

mrs.holmes

不太能明白，为什么在create函数里面调用moving函数不需要传入direction和step参数

水色纸飞机~

勉强看懂了  但对闭包理解还是不够深

Jeanses

完全看不懂呀 从入门到放弃啊

eachill

测试题：
      
0. 请使用lambda表达式将下边函数转变为匿名函数？
def fun_A(x, y=3):
        return x * y
复制代码

A = lambda x,y=3 : x*y;

1. 请将下边的匿名函数转变为普通的屌丝函数？
lambda x : x if x % 2 else None
复制代码

def fun_X(x):
        if x % 2:
                return x
        else:
                return None


2. 感受一下使用匿名函数后给你的编程生活带来的变化？
在整个程序只需要调用一两次的函数，可以通过使用匿名函数避免了给它起名字的烦恼。
而且写起来比较有逼格


3. 你可以利用filter()和lambda表达式快速求出100以内所有3的倍数吗？
threesome = list(filter(lambda x : x % 3 == 0 , range(1,101)))
print(threesome)


4. 还记得列表推导式吗？完全可以使用列表推导式代替filter()和lambda组合，你可以做到吗？
可以

5. 还记得zip吗？使用zip会将两数以元祖的形式绑定在一块，例如：       
>>> list(zip([1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))
[(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]
复制代码
但如果我希望打包的形式是灵活多变的列表而不是元祖（希望是[[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]这种形式），你能做到吗？（采用map和lambda表达式）

match = list(map(lambda x,y : [x,y], [x for x in range(1,10,2)], [y for y in range(2,11,2)]))


6. 请目测以下表达式会打印什么？
def make_repeat(n):
        return lambda s : s * n

double = make_repeat(2)
print(double(8))
print(double('FishC'))
复制代码

16
FishCFishC

0xJoEcO01

看是看懂了，但是你让我写，我可能写不来，好菜啊。