*****假期作业（day16）******

1. 实现双人游戏之2048；

import curses
from itertools import chain
from random import choice
import time
class GameField(object):
    # 初始化信息
    def __init__(self, width=4, height=4, win_value=2048):
        self.width = width
        self.height = height
        self.win_value = win_value
        self.score1 = 0  # 当前得分
        self.highscore1 = 0  # 最高分
        self.score2=0
        self.highscore2=0
        self.moves = {}
        self.moves['Left1'] = self.is_move_left
        self.moves['Right1'] = self.is_move_right
        self.moves['Down1'] = self.is_move_down
        self.moves['Up1'] = self.is_move_up
        self.moves['Left2'] = self.is_move_left
        self.moves['Right2'] = self.is_move_right
        self.moves['Down2'] = self.is_move_down
        self.moves['Up2'] = self.is_move_up

        self.movesDict = {}
        self.movesDict['Left1'] = self.move_left
        self.movesDict['Right1'] = self.move_right
        self.movesDict['Down1'] = self.move_down
        self.movesDict['Up1'] = self.move_up
        self.movesDict['Left2'] = self.move_left
        self.movesDict['Right2'] = self.move_right
        self.movesDict['Down2'] = self.move_down
        self.movesDict['Up2'] = self.move_up

    def reset(self):  # 重置棋盘
        if self.score1 > self.highscore1:
            self.highscore1 = self.score1  # 更新最高分
        self.score1 = 0
        if self.score2>self.highscore2:
            self.highscore2=self.score2
        self.score2=0
        # 需求1: 生成4*4的棋盘， 其中数据结构选择列表嵌套列表;
        self.field1 = [[0 for j in range(self.width)]
                      for i in range(self.height)]
        self.field2 = [[0 for j in range(self.width)]
                      for i in range(self.height)]
        # 在棋盘的一个随机位置插入一个数字2或者4
        self.random_create(self.field1)
        self.random_create(self.field1)
        self.random_create(self.field2)
        self.random_create(self.field2)

    def random_create(self,field):
        # 在棋盘的一个随机位置插入一个数字2或者4
        # field[0][3] = 2
        while True:
            i, j = choice(range(self.height)), choice(range(self.width))
            if field[i][j] == 0:
                field[i][j] = choice([2, 2, 2, 4])
                break

    def score_compare(self,stdscr):
        if self.score1>self.score2:
            stdscr.addstr('p1win'.center(30,'@'))
        elif self.score2>self.score1:
            stdscr.addstr('p2win'.center(30,'@'))
        else:
            stdscr.addstr('draw tie dogfall a dead heat deuce')

    def draw(self, stdscr):
        def draw_sep():
            stdscr.addstr('+' + "-----+" * self.width + '\n')

        def draw_one_row(row):
            stdscr.addstr("".join('|{:^5}'.format(num) if num != 0 else "|     " for num in row) + '|' + '\n')
        def draw_more_row(field,score,highscore):
            stdscr.addstr("当前分数:" + str(score) + '\n')
            if highscore != 0:
                stdscr.addstr("最高分:" + str(highscore) + '\n')
            for row in field:
                draw_sep()
                draw_one_row(row)
            draw_sep()

        # 清屏
        stdscr.clear()
        stdscr.addstr("2048".center(50, '-') + '\n')
        stdscr.addstr('p1'.center(30,'*')+'\n')
        draw_more_row(self.field1,self.score1,self.highscore1)
        stdscr.addstr('p2'.center(30, '*') + '\n')
        draw_more_row(self.field2,self.score2,self.highscore2)

        # 判断是否赢或者输
        if self.is_win(stdscr):
            self.score_compare(stdscr)
        if self.is_gameover():
            self.score_compare(stdscr)
            stdscr.addstr("游戏结束!!!!" + '\n')
        stdscr.addstr(" 游戏帮助: p1:wsad   p2:上下左右键  (R)Restart     Q(Quit)")

    def is_win(self,stdscr):
        return max(chain(*self.field1))>=self.win_value \
               or max(chain(*self.field2))>=self.win_value

    def is_gameover(self):
            return not (any([self.move_is_possible(direction,self.field1) for direction in self.moves])
                        and any([self.move_is_possible(direction,self.field2) for direction in self.moves]))

    @staticmethod
    def invert(field):
        # 矩阵进行反转
        return [row[::-1] for row in field]
        # print(invert(li))

    @staticmethod
    # 矩阵的转置
    def transpose(field):
        # *field ==== [1,2,3] [4,5,6] [7,8,9]
        # zip(*field)   =====  [1,4,7], [2,5,8] [3,6,9]
        # list(zip(*field)) ======  [(1, 4, 7), (2, 5, 8), (3, 6, 9)]  但是将来元素需要修改，必须转换为列表
        return [list(row) for row in zip(*field)]

    @staticmethod
    def is_row_change(row):
        # row
        # 需求3. 判断一行内容是否可移动。
        def is_change(i):  # 0
            # 判断每两个元素之间是否可移动
            if row[i] == 0 and row[i + 1] != 0:
                return True
            if row[i] != 0 and row[i] == row[i + 1]:
                return True
            return False

        return any([is_change(index) for index in range(len(row) - 1)])

    # 判断这个棋盘是否可向左移动
    def is_move_left(self, field):
        return any([self.is_row_change(row) for row in field])

    def is_move_right(self, field):
        #  对于列表元素进行反转
        field = self.invert(field)
        print(field)
        return self.is_move_left(field)

    def is_move_up(self, field):
        # 对于列表元素进行转置
        field = self.transpose(field)
        return self.is_move_left(field)

    def is_move_down(self, field):
        # 反转+ 转置
        field = self.transpose(field)
        return self.is_move_right(field)

    def move_is_possible(self, direction,field):  # 'left'
        # 判断用户选择的方向是否可移动
        if direction in self.moves:
            return self.moves[direction](field)
        else:
            return False

    # 将棋盘每一行的非0数向前移动， 0向后移动;
    @staticmethod
    def tight(row):  # [2, 0, 2, 0]
        # 最快的方式， 通过排序实现...........
        return sorted(row, key=lambda x: 1 if x == 0 else 0)

    def merge(self, row,mode):  # [2,2,0,0]
        for i in range(len(row) - 1):
            # 如果两个值相等， 前一个元素*2, 后一个元素改为0。
            if row[i] == row[i + 1]:
                row[i] *= 2
                row[i + 1] = 0
                # 如果覆盖成功， 就给得分
                if mode=='p1':
                    self.score1+=row[i]
                if mode=='p2':
                    self.score2+=row[i]
        return row

    def move_row_left(self, row,mode):
        return self.tight(self.merge(self.tight(row),mode))

    def move_left(self, field,mode):
        return [self.move_row_left(row,mode) for row in field]

    def move_right(self, field,mode):
        return self.invert([self.move_row_left(row,mode) for row in self.invert(field)])

    def move_up(self, field,mode):
        return self.transpose([self.move_row_left(row,mode) for row in self.transpose(field)])

    def move_down(self, field,mode):
        return self.transpose(self.move_right(self.transpose(field),mode))

    def move(self, direction):  # 'left'
        # 判断用户选择的方向是否可移动

        if direction in self.movesDict:
            # 判断是否可移动
            if self.move_is_possible(direction,self.field1) \
                    and direction in ['Left1','Right1','Down1','Up1']:
                self.field1 = self.movesDict[direction](self.field1,'p1')
                self.random_create(self.field1)
                return True
            elif self.move_is_possible(direction,self.field2) \
                    and direction in ['Left2','Right2','Down2','Up2']:
                self.field2 = self.movesDict[direction](self.field2,'p2')
                self.random_create(self.field2)
                return True
        else:
            return False

def get_user_action(stdscr):
    action = stdscr.getch()
    if action == curses.KEY_UP:
        return 'Up2'
    if action == curses.KEY_DOWN:
        return 'Down2'
    if action == curses.KEY_LEFT:
        return 'Left2'
    if action == curses.KEY_RIGHT:
        return 'Right2'
    if action == ord('w'):
        return 'Up1'
    if action == ord('s'):
        return 'Down1'
    if action == ord('a'):
        return 'Left1'
    if action == ord('d'):
        return 'Right1'
    if action == ord('r'):
        return 'Restart'
    if action == ord('q'):
        return 'Exit'

def main(stdscr):
    action = stdscr.getch()

    def init():
        # 初始化棋盘的操作
        game_field.reset()
        game_field.draw(stdscr)
        return 'Game'

    def game():
        game_field.draw(stdscr)
        action = get_user_action(stdscr)
        if action == 'Restart':
            return 'Init'
        if action == 'Exit':
            return 'Exit'
        if game_field.move(action):
            if game_field.is_win(stdscr):
                return 'Win'
            if game_field.is_gameover():
                return 'GameOver'
        return 'Game'

    def not_game():
        game_field.draw(stdscr)
        while True:
            action = get_user_action(stdscr)
            if action == 'Restart':
                return 'Init'
            if action == 'Exit':
                return 'Exit'

    state_actions = {
        'Init': init,
        'Game': game,
        'Win': not_game,
        'GameOver': not_game,

    }
    game_field = GameField()
    state = 'Init'

    # 如果当前状态不是退出， 那么一直执行
    while state != 'Exit':
        # 执行当前状态需要操作的内容， 并返回， 下一次的状态为什么.
        state = state_actions[state]()
curses.wrapper(main)

1. 面向对象，文件操作与数据库操作复习题目:

文件score.dat中保存的是100名学生的姓名和PYthon课、高数和英语成绩。
（1）定义学生类，其中包含姓名、Python课、高数和英语成绩及总分、均分数据成员，成员函数根据需要确定。
（2）读入这名学生的成绩，用对象列表进行存储。
（3）求出各科和总分的最高分。
（4）请按总分的降序（高成绩在前，低成绩在后）排序
（5）在屏幕上显示各科及总分的最高分，排序后的成绩单（包括总分）保存到文件odered_score.dat中。
（6） 将文件中的所有学生信息， 保存在mariadb数据库中;

import random
def create_scoredata(filename='score.dat'):
    databases=('name'+str(i)+','+str(random.randint(0,100))+','+str(random.randint(0,100))
               +','+str(random.randint(0,100)) for i in range(100))
    with open(filename,mode="a+") as f:
        for items in databases:
            f.write(items+'\n')
def reade_scoreadata(filename='score.dat'):
    with open(filename) as f:
        readelise=f.readlines()
    return [items[0].split(',') for items in [reade.split() for reade in readelise]]
class Student(object):
    def __init__(self,list):
        self.total=0
        self.average=0
        self.list=list
    def Total_average(self):
        for items in self.list:
            self.total=int(items[1])+int(items[2])+int(items[3])
            self.average=self.total/3.0
            items.append(self.total)
            items.append(self.average)
    def max_high(self):
        self.python=max([items[1]for items in self.list])
        self.math=max([items[2]for items in self.list])
        self.English=max([items[3]for items in self.list])
        self.total=max([items[4]for items in self.list])
        print('各科的最高分及总分的最高分:python:%s math:%s English:%s 总分:%s'%(self.python,self.math,self.English,self.total))
    def sorte(self):
        return sorted(list,key=lambda x:-x[4])
def write_data(list,filename='odered_score.dat'):
    with open(filename,mode='w+') as f:
        for items in list:
            items[4]=str(items[4])
            items[5]=str(items[5])
            f.write(','.join(items)+'\n')
if __name__=='__main__':
    create_scoredata()
    list=reade_scoreadata('score.dat')
    student=Student(list)
    student.Total_average()
    student.max_high()
    list1=student.sorte()
    write_data(list1)

3. 知识点复习
题目描述
正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。

• 输入描述: 输入两个正整数A和B。
• 输出描述: 输出A和B的最小公倍数。
  示例1
• 输入
  5
  7
• 输出
  35

num1 = int(input('Num1:'))
num2 = int(input('Num2:'))
min_num = num1 if num1<num2 else num2
for i in range(1,min_num+1):
        if num1%i == 0 and num2%i ==0:
                gys=i
lcm = int((num1*num2)/gys)
print("%s和%s的最大公约数为%s"  %(num1,num2,gys))
print("%s和%s的最小公倍数为%s"  %(num1,num2,lcm))

1. 题目描述
   Catcher 是MCA国的情报员，他工作时发现敌国会用一些对称的密码进行通信，比如像这些ABBA，ABA，A，123321，但是他们有时会在开始或结束时加入一些无关的字符以防止别国破解。比如进行下列变化 ABBA->12ABBA,ABA->ABAKK,123321->51233214　。因为截获的串太长了，而且存在多种可能的情况（abaaab可看作是aba,或baaab的加密形式），Cathcer的工作量实在是太大了，他只能向电脑高手求助，你能帮Catcher找出最长的有效密码串吗？
   （注意：记得加上while处理多个测试用例）

   • 输入描述:输入一个字符串
   • 输出描述:返回有效密码串的最大长度

示例1
- 输入
ABBA
- 输出
4

while 1:
    s=input('输入:')
    slen=len(s)
    print(max([ len(s[i:j]) for i in range(slen) for j in range(i+1,slen+1) 
                if s[i:j]==s[i:j][::-1]]))