python编程构建知识库
 Python是一种通用的编程语言，可用于创建桌面应用程序，3D图形，视频游戏甚至网站。 它是一种很棒的第一门编程语言，因为它易于学习，并且比诸如C，C ++或Java的复杂语言更简单。 即便如此，Python足够强大和强大，足以创建高级应用程序，并且几乎所有使用计算机的行业都在使用它。 无论有没有编程经验，Python都是适合年轻人和老年人的好语言。 
 安装Python 
 在学习Python之前，您可能需要安装它。 
 Linux：如果您使用Linux，则已经包含Python，但是请确保您具有Python 3。 要检查安装的版本，请打开一个终端窗口，然后键入： 
 python3 --version 
 如果找不到该命令，则需要从程序包管理器中安装Python 3。 
 MacOS：如果您使用的是Mac，请按照上面针对Linux的说明进行操作，以查看是否已安装Python 3。 MacOS没有内置的软件包管理器，因此，如果找不到Python 3，请从python.org/downloads/mac-osx安装它。 尽管macOS确实安装了Python 2，但您应该学习Python 3。 
 Windows： Microsoft Windows当前不随Python一起提供。 从python.org/downloads/windows安装。 确保在安装向导中选择“ 将Python添加到PATH ”。 阅读我的文章“ 如何在Windows上安装Python”以获取特定于Microsoft Windows的说明。 
 运行IDE 
 要使用Python编写程序，您真正需要的只是一个文本编辑器，但是拥有集成开发环境（IDE）会很方便。 IDE将文本编辑器与一些友好且有用的Python功能集成在一起。 空闲3和忍者IDE是需要考虑的两个选项。 
 闲置3 
 Python带有一个称为IDLE的基本IDE。 

 闲 

 它具有关键字突出显示以帮助检测输入错误，并具有“运行”按钮以快速，轻松地测试代码。 要使用它： 

 在Linux或macOS上，启动终端窗口，然后输入idle3 。  

 在Windows上，从“开始”菜单启动Python 3。 

 如果在“开始”菜单中没有看到Python，请在“开始”菜单中键入cmd来启动Windows命令提示符，然后键入C：\ Windows \ py.exe 。 
 如果这样不起作用，请尝试重新安装Python。 确保在安装向导中选择“ 将Python添加到PATH ”。 请参阅docs.python.org/3/using/windows.html以获得详细说明。 
 如果仍然不能解决问题，请使用Linux。 它是免费的，而且只要将Python文件保存到USB拇指驱动器，您甚至无需安装即可使用它。 



 忍者IDE 
 Ninja-IDE是出色的Python IDE。 它具有关键字突出显示功能，可帮助检测拼写错误，引号和括号是否完整，从而避免语法错误，行号（调试时很有用），缩进标记以及“运行”按钮来快速轻松地测试代码。 

 忍者IDE 

 要使用它： 

 安装Ninja-IDE。 如果您使用的是Linux，最简单的方法就是使用软件包管理器； 否则，请从NINJA-IDE的网站下载正确的安装程序版本。 
 启动Ninja-IDE。 
 转到“编辑”菜单，然后选择“首选项”。 
 在“首选项”窗口中，单击“执行”选项卡。 
 在执行选项卡中，将python更改为python3 。 


 Ninja-IDE中的Python3 

 告诉Python怎么做 
 关键字告诉Python您想要它做什么。 在“ IDLE”或“ Ninja”中，转到“文件”菜单并创建一个新文件。 忍者用户：不要创建新项目，而要创建一个新文件。 
 在新的空文件中，将其输入IDLE或Ninja： 
 print ( "Hello world." ) 

 如果使用的是IDLE，请转到“运行”菜单，然后选择“运行模块”选项。 
 如果使用的是Ninja，请单击左侧按钮栏中的“运行文件”按钮。 


 在忍者中运行文件 

 关键字print告诉Python打印出您在括号和引号中输入的所有文本。 
 不过，那不是很令人兴奋。 从本质上讲，Python只能访问基本关键字，例如print ， help ，基本数学函数等。 
 使用import关键字可以加载更多关键字。 在IDLE或Ninja中启动一个新文件，并将其命名为pen.py。 
 警告 ：请勿调用文件turtle.py ，因为turtle.py是包含您要控制的turtle程序的文件的名称。 命名文件turtle.py会使Python 感到困惑，因为它会认为您想导入自己的文件。 
 Turtle是一个有趣的模块。 将此代码键入您的文件，然后运行它： 
 import turtle 



turtle . begin_fill ( ) 

turtle . forward ( 100 ) 

turtle . left ( 90 ) 

turtle . forward ( 100 ) 

turtle . left ( 90 ) 

turtle . forward ( 100 ) 

turtle . left ( 90 ) 

turtle . forward ( 100 ) 

turtle . end_fill ( ) 
 看看您可以使用turtle模块绘制哪些形状。 
 要清除乌龟绘图区域，请使用turtle.clear（）关键字。 您认为关键字turtle.color（“ blue”）有什么用？ 
 您可以尝试一些更复杂的代码以获得相似的结果。 您可以使用while循环 ，告诉Python进行四次操作， 而无需手动编码每条线和每转弯：绘制一条线然后转弯。 Python能够使用一个名为counter的变量来跟踪其执行这些操作的次数。 您很快就会了解有关变量的更多信息，但是现在看看是否可以告诉您计数器和while循环如何交互。 
 import turtle as t

import time 



t. color ( "blue" ) 

t. begin_fill ( ) 



counter = 0 



while counter < 4 :

    t. forward ( 100 ) 

    t. left ( 90 ) 

    counter = counter+ 1 



t. end_fill ( ) 

time . sleep ( 2 ) 
 一旦运行了脚本，就该探索一个更好的模块了。 
 通过制作游戏学习Python 
 要了解有关Python工作原理的更多信息，并为使用图形进行更高级的编程做准备，让我们关注游戏逻辑。 在本教程中，我们还将通过制作一个基于文本的游戏来学习一些计算机程序的结构，在该游戏中，计算机和玩家将虚拟掷骰，而掷骰最高的则获胜。 
 规划游戏 
 在编写代码之前，考虑一下您打算编写什么很重要。 许多程序员在开始编写代码之前就编写了简单的文档 ，因此他们的目标是进行编程。 如果您随游戏一起提供了文档，则骰子程序的外观如下： 

 开始骰子游戏，然后按Return或Enter键滚动。 
 结果将显示在屏幕上。 
 提示您再次滚动或退出。 

 这是一个简单的游戏，但是文档向您介绍了很多您需要做的事情。 例如，它告诉您需要以下组件来编写此游戏： 

 玩家：您需要一个人玩游戏。 
 AI：计算机也必须掷骰子，否则玩家无人赢或输。 
 随机数：常见的六面骰子呈现1到6之间的随机数。 
 运算符：简单的数学运算可以将一个数字与另一个数字进行比较，看哪个更高。 
 输赢信息。 
 再次播放或退出的提示。 

 制作骰子游戏Alpha 
 很少有程序以其所有功能开头，因此第一个版本将仅实现基础知识。 首先有两个定义： 
 变量是可以更改的值，在Python中经常使用它们。 每当需要程序“记住”某些内容时，就使用变量。 实际上，几乎所有与代码一起使用的信息都存储在变量中。 例如，在数学方程x + 5 = 20中 ，变量是x ，因为字母x是值的占位符。 
 整数是数字； 它可以是正数或负数。 例如，1和-1都是整数。 14、21甚至10947也是如此。 
 Python中的变量易于创建且易于使用。 骰子游戏的初始版本使用两个变量： player和ai 。 
 在一个名为dice_alpha.py的新文本文件中输入以下代码： 
 import random 



player = random . randint ( 1 , 6 ) 

ai = random . randint ( 1 , 6 ) 



if player > ai :

    print ( "You win" )  # notice indentation 

else :

    print ( "You lose" ) 
 启动您的游戏以确保其正常运行。 
 这个骰子游戏的基本版本运行良好。 它可以达到游戏的基本目标，但感觉却不像游戏。 玩家永远不知道自己滚动了什么或电脑滚动了什么，即使玩家想再次玩游戏，游戏也结束了。 
 这在软件的第一个版本（称为Alpha版本）中很常见。 现在您已经确定可以完成主要部分（滚动模具）了，现在该添加到程序了。 
 改善游戏 
 在您的游戏的第二个版本（称为Beta）中，进行了一些改进，使其看起来更像游戏。 
 1.描述结果 
 与其仅仅告诉玩家他们是否赢了，不如告诉他们自己成功了。 尝试对代码进行以下更改： 
player = random . randint ( 1 , 6 ) 

print ( "You rolled " + player ) 



ai = random . randint ( 1 , 6 ) 

print ( "The computer rolled " + ai ) 
 如果您现在运行游戏，它将崩溃，因为Python认为您正在尝试数学。 它认为您正在尝试添加字母“ You roll”以及当前存储在player变量中的任何数字。 
 您必须告诉Python将player和ai变量中的数字视为句子中的单词（字符串），而不是数学方程式中的数字（整数）。 
 对您的代码进行以下更改： 
player = random . randint ( 1 , 6 ) 

print ( "You rolled " + str ( player ) ) 



ai = random . randint ( 1 , 6 ) 

print ( "The computer rolled " + str ( ai ) ) 
 立即运行您的游戏以查看结果。 
 2.慢下来 
 电脑速度很快。 人类有时可能很快，但在游戏中，建立悬念通常更好。 您可以使用Python的时间功能在可疑阶段降低游戏速度。 
 import random 

import time 



player = random . randint ( 1 , 6 ) 

print ( "You rolled " + str ( player ) ) 



ai = random . randint ( 1 , 6 ) 

print ( "The computer rolls...." ) 

time . sleep ( 2 ) 

print ( "The computer has rolled a " + str ( player ) ) 



if player > ai :

    print ( "You win" )  # notice indentation 

else :

    print ( "You lose" ) 
 启动您的游戏以测试您的更改。 
 3.发现联系 
 如果您玩够了游戏，您会发现，即使您的游戏看似正常运行，但实际上存在一个错误：当玩家和计算机掷相同的数字时，它不知道该怎么办。 
 为了检查一个值是否等于另一个值，Python使用== 。 那是两个相等的符号，而不仅仅是一个。 如果只使用一个，Python会认为您正在尝试创建一个新变量，但实际上是在进行数学运算。 
 如果您想拥有两个以上的选项（即赢或输），则可以使用Python的关键字elif ， 否则为if 。 这使你的代码进行检查，看到一些成果中的任何一个是否真实，而不是只检查一两件事是否属实。 
 像这样修改您的代码： 
 if player > ai :

    print ( "You win" )  # notice indentation 

elif player == ai:

    print ( "Tie game." ) 

else :

    print ( "You lose" ) 
 几次启动您的游戏，看看是否可以配合计算机。 
 编程最终版本 
 骰子游戏的beta版本具有功能性，与alpha相比，它更像是一款游戏。 对于最终版本，请创建您的第一个Python 函数 。 
 函数是可以作为不同单元调用的代码的集合。 函数之所以重要，是因为大多数应用程序中都包含许多代码，但并非所有代码都必须立即运行。 通过功能可以启动应用程序并控制发生的情况和时间。 
 将代码更改为此： 
 import random 

import time 



def dice ( ) :

    player = random . randint ( 1 , 6 ) 

    print ( "You rolled " + str ( player ) ) 



    ai = random . randint ( 1 , 6 ) 

    print ( "The computer rolls...." ) 

    time . sleep ( 2 ) 

    print ( "The computer has rolled a " + str ( ai ) ) 



    if player > ai :

        print ( "You win" )  # notice indentation 

    else :

        print ( "You lose" ) 



    print ( "Quit? Y/N" ) 

    continue = input ( ) 



    if continue == "Y" or continue == "y" :

        exit ( ) 

    elif continue == "N" or continue == "n" :

        pass 

    else :

        print ( "I did not understand that. Playing again." ) 
 此版本的游戏询问玩家是否希望在玩完游戏后退出游戏。 如果他们以Y或y响应，则会调用Python的exit函数，然后退出游戏。 
 更重要的是，您已经创建了自己的名为dice的函数。 骰子功能不会立即运行。 实际上，如果您在此阶段尝试游戏，它不会崩溃，但也不能完全运行。 为了使dice函数真正起作用，您必须在代码中调用它 。 
 将此循环添加到现有代码的底部。 前两行仅用于上下文，并强调缩进和不缩进。 密切注意缩进。 
    else :

        print ( "I did not understand that. Playing again." ) 



# main loop 

while True :

    print ( "Press return to roll your die." ) 

    roll = input ( ) 

    dice ( ) 
 While True代码块首先运行。 因为从定义上讲True始终为true，所以此代码块始终运行，直到Python告诉它退出为止。 
 而True代码块是一个循环。 它首先提示用户开始游戏，然后调用您的骰子功能。 游戏就是这样开始的。 当骰子功能结束时，循环将再次运行或退出，具体取决于玩家如何回答提示。 
 使用循环运行程序是编写应用程序最常见的方法。 该循环确保应用程序保持打开状态足够长的时间，以使计算机用户可以使用应用程序中的功能。 
 下一步 
 现在您了解了Python编程的基础知识。 本系列的下一篇文章介绍如何使用PyGame编写视频游戏， PyGame是一个模块，其功能比乌龟还要多，但也要复杂得多。 
翻译自: https://opensource.com/article/17/10/python-101
python编程构建知识库

题设：现在有100个人，每个人手里有100块钱，现在游戏开始，每个人都拿出一块钱给随机的一个人，那么这个游戏一直持续下去，会是什么结果呢？
曾经有人拿这个问题问过五位非常聪明的博士，他们的答案不尽相同，都是很平均，差不了多少
那么真实的结果到底是什么情况呢，现在我们用java swing的GUI编程来模拟一下这个过程，看看最终结果如何
package com.company;

import java.awt.*;
import javax.swing.*;

public class AlgoFrame extends JFrame{

    private int canvasWidth;
    private int canvasHeight;

    public AlgoFrame(String title, int canvasWidth, int canvasHeight){

        super(title);

        this.canvasWidth = canvasWidth;
        this.canvasHeight = canvasHeight;

        AlgoCanvas canvas = new AlgoCanvas();
        setContentPane(canvas);
        pack();

        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setResizable(false);

        setVisible(true);
    }

    public AlgoFrame(String title){

        this(title, 1024, 768);
    }

    public int getCanvasWidth(){return canvasWidth;}
    public int getCanvasHeight(){return canvasHeight;}


    private int[] money;
    public void render(int[] money){
        this.money = money;
        repaint();
    }

    private class AlgoCanvas extends JPanel{

        public AlgoCanvas(){
            // 双缓存
            super(true);
        }

        @Override
        public void paintComponent(Graphics g) {
            super.paintComponent(g);

            Graphics2D g2d = (Graphics2D)g;

            // 抗锯齿
            RenderingHints hints = new RenderingHints(
                    RenderingHints.KEY_ANTIALIASING,
                    RenderingHints.VALUE_ANTIALIAS_ON);
            hints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
            g2d.addRenderingHints(hints);

            // 具体绘制
            int w=canvasWidth/money.length;
            for(int i=0;i<money.length;i++) {
                if(money[i] > 0) {
                    AlgoVisHelper.setColor(g2d,AlgoVisHelper.Blue);
                    AlgoVisHelper.fillRectangle(g2d,
                            i * w + 1, canvasHeight/2 - money[i], w - 1, money[i]);
                }
                else if(money[i] < 0){
                    AlgoVisHelper.setColor(g2d,AlgoVisHelper.Red);
                    AlgoVisHelper.fillRectangle(g2d,
                            i * w + 1, canvasHeight/2, w - 1, -money[i]);
                }
            }
        }

        @Override
        public Dimension getPreferredSize(){
            return new Dimension(canvasWidth, canvasHeight);
        }
    }
}


package com.company;
import javax.swing.*;
import java.awt.*;
import java.awt.geom.*;

import java.lang.InterruptedException;

public class AlgoVisHelper {

    private AlgoVisHelper(){}

    public static final Color Red = new Color(0xF44336);
    public static final Color Pink = new Color(0xE91E63);
    public static final Color Purple = new Color(0x9C27B0);
    public static final Color DeepPurple = new Color(0x673AB7);
    public static final Color Indigo = new Color(0x3F51B5);
    public static final Color Blue = new Color(0x2196F3);
    public static final Color LightBlue = new Color(0x03A9F4);
    public static final Color Cyan = new Color(0x00BCD4);
    public static final Color Teal = new Color(0x009688);
    public static final Color Green = new Color(0x4CAF50);
    public static final Color LightGreen = new Color(0x8BC34A);
    public static final Color Lime = new Color(0xCDDC39);
    public static final Color Yellow = new Color(0xFFEB3B);
    public static final Color Amber = new Color(0xFFC107);
    public static final Color Orange = new Color(0xFF9800);
    public static final Color DeepOrange = new Color(0xFF5722);
    public static final Color Brown = new Color(0x795548);
    public static final Color Grey = new Color(0x9E9E9E);
    public static final Color BlueGrey = new Color(0x607D8B);
    public static final Color Black = new Color(0x000000);
    public static final Color White = new Color(0xFFFFFF);

    public static void strokeCircle(Graphics2D g, int x, int y, int r){

        Ellipse2D circle = new Ellipse2D.Double(x-r, y-r, 2*r, 2*r);
        g.draw(circle);
    }

    public static void fillCircle(Graphics2D g, int x, int y, int r){

        Ellipse2D circle = new Ellipse2D.Double(x-r, y-r, 2*r, 2*r);
        g.fill(circle);
    }

    public static void strokeRectangle(Graphics2D g, int x, int y, int w, int h){

        Rectangle2D rectangle = new Rectangle2D.Double(x, y, w, h);
        g.draw(rectangle);
    }

    public static void fillRectangle(Graphics2D g, int x, int y, int w, int h){

        Rectangle2D rectangle = new Rectangle2D.Double(x, y, w, h);
        g.fill(rectangle);
    }

    public static void setColor(Graphics2D g, Color color){
        g.setColor(color);
    }

    public static void setStrokeWidth(Graphics2D g, int w){
        int strokeWidth = w;
        g.setStroke(new BasicStroke(strokeWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
    }

    public static void pause(int t) {
        try {
            Thread.sleep(t);
        }
        catch (InterruptedException e) {
            System.out.println("Error sleeping");
        }
    }

    public static void putImage(Graphics2D g, int x, int y, String imageURL){

        ImageIcon icon = new ImageIcon(imageURL);
        Image image = icon.getImage();

        g.drawImage(image, x, y, null);
    }

    public static void drawText(Graphics2D g, String text, int centerx, int centery){

        if(text == null)
            throw new IllegalArgumentException("Text is null in drawText function!");

        FontMetrics metrics = g.getFontMetrics();
        int w = metrics.stringWidth(text);
        int h = metrics.getDescent();
        g.drawString(text, centerx - w/2, centery + h);
    }
}


package com.company;
import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.lang.reflect.Array;
import java.util.Arrays;

public class AlgoVisualizer {

    private static int DELAY = 40;
    private int[] money;        // 数据
    private AlgoFrame frame;    // 视图

    public AlgoVisualizer(int sceneWidth, int sceneHeight){

        // 初始化数据
        money = new int[100];
        for(int i=0;i<money.length;i++)
            money[i] = 100;
        // 初始化视图
        EventQueue.invokeLater(() -> {
            frame = new AlgoFrame("Welcome", sceneWidth, sceneHeight);

            new Thread(() -> {
                run();
            }).start();
        });
    }

    // 动画逻辑
    private void run(){

        while(true){

            Arrays.sort(money);
            frame.render(money);
            AlgoVisHelper.pause(DELAY);
            for(int k=0;k<50;k++){
                for(int i=0;i<money.length;i++) {
                    //if(money[i]>0){
                    int j = (int) (Math.random() * money.length);
                    money[i] -= 1;
                    money[j] += 1;
                    //}
                }
            }

        }
    }

    public static void main(String[] args) {

        int sceneWidth = 1000;
        int sceneHeight = 800;

        // TODO: 根据需要设置其他参数，初始化visualizer
        AlgoVisualizer visualizer = new AlgoVisualizer(sceneWidth, sceneHeight);
    }
}


我们现在运行这个程序，来看看结果到底是不是五位博士的预想呢？


我们可以从图片显示的结果来看出，财富的分配是极为不均匀的，红色表示手中的100块给完之后，还欠的外债
至于发生这个状态的原因，我很欣赏的一位算法大神liuyubobobo解释这个原因：简单来分析的话，可以认为100个人，每个人100块钱，那么一共就有1W块钱，所以这个问题可以看做将1W块钱分配给100个人，有多少分发，答案可想而知，有很多很多种分发，那么像那五位博士们所说的大家的财富都很平均只是其中的一种状态，而绝大部分的状态都是很不均匀的，所以才导致这个结果，也有许多学者认为这个问题可以抽象是一个物理学问题，在一个密闭环境下热量的变化，随着时间的变化而引起熵的变化

　　Java作为一种常见的计算机编程语言，它具有简单、稳定、多线等特点，被广泛运用于PC、游戏控制台、数据中心、超级计算机以及互联网，相对于C++，Java会稍微容易些，但是依然需要我们学会很多的编程，作为一名程序员，如何系统的掌握这些程序呢？下面是分享的用思维导图学习Java编程方法介绍，一起看看吧！
　　为什么要用思维导图学习Java呢？
　　首先思维导图是一种结构性模型，有利于整合知识框架，其次，思维导图是一种带色彩的图文结合，相对于单纯的文字而言，更好的被人们所记住，迅捷画图作为一款好用的思维导图工具，为我们学习Java知识提供强有力的支持。下面将方法分享给大家
　　一．套用模板进行绘制
　　1.如果你是一名新手，进入迅捷画图模板导航区，在上方搜索栏目中输入模板关键词，这时在下方栏目中将出现相对应的模板；

　　2.点击模板在右方出现的栏目将出现模板的简介及缩略图，让你在选择的同时有个大致的了解；

　　3.点击【使用模板】将进入在线绘制界面，整张思维导图绘制完成后，点击右上角【导出】在弹出来的菜单栏中选择自己需要的格式进行导出即可；

　　二．利用在线网站进行绘制
　　1.首先，进入迅捷画图，点击页面中央【立即体验】进入类型选择界面；

　　2.点击左上角【新建文件】选择【思维导图】进入在线绘制界面；

　　3.在跳转的页面有很多的工具栏，这些在绘制的过程中都是可以使用的，首先将中心主题确定，沿着中心主题进行节点的添加，点击左上角【插入下级主题】或者【插入同级主题】即可；

　　4.新的节点添加之后，我们需要做的就是将内容进行添加，双击文本框或者点击上方栏目【编辑】即可；

　　5.【外观】选项中可以对导图的整体颜色及结构根据自己的需要进行设置；

　　6.内容填充完后，整体效果要是显得不够丰富，点击上方栏目【链接】或【图片】将链接及图片进行添加，丰富思维导图的内容；

　　7.这时一张完整的思维导图就在线制作完成了，如何将其进行导出呢？方法很简单，点击右上角【导出】在弹出的菜单栏中选择自己需要的格式进行导出即可

　　以上就是分享的如何用思维导图学习Java方法介绍，两种方法的过程阐述的还是比较详细的，迅捷画图是一款可以直接在线绘制思维导图、流程图等多种图形的画图工具，里面有很多的模板，可以直接套用模板在线进行编辑，同时支持多种格式的导出与保存，很适合新手使用哦！
转载于:https://blog.51cto.com/14181138/2366561

展开全部
熟悉2113以下关键东西，可以边学边做，定期训练，经常5261思考4102，长期积累：
1、语法。
2、基础理论1653（数学、数据结构、算法等）。
3、设计方法（编程原则、设计模式、框架设计等）。
4、库（核心、基础、UI、扩展、游戏引擎等）。
5、计算机相关（操作系统、网络、图形学等）。
6、领域知识（游戏设计、网站设计等）。
7、开发工具（编辑器、IDE、自动部署等）。
8、项目管理（进度管理、分工协作、Bug管理、版本控制等）。
最普遍也是最重要的能力：创造力。努力分析并理解好做什么以及怎么做。要知道上面那些东西一开始都是不存在的。
具体方法包括：
1、快速阅读入门教程和书籍，适合学习语言和基础库。比如我学Java读的《Java编程思想》，练习题做过一点，然后学ActionScript就没读过书，只读过Adobe官方文档《ActionScript 3.0编程》。
2、阅读库的文档、实例、源码。比如Flash、Flex开发，熟悉官方API很重要，很多细节要具体使用时才注意到，这时候最好做个笔记，虽然我从没看过我的笔记。
3、做一个自己感兴趣或熟悉的小项目，比如我就以黑白棋游戏作为多个语言的试水项目，一样的逻辑，便于把关注点放在语言特点上。
4、自己动手丰衣足食。厨师有菜谱，程序员可没菜谱。比如我做游戏，最关键的游戏编程知识全部是动手学出来的，很少有专门针对某个业务领域（如游戏）的编程书籍，要么是入门书，要么是模式书（如算法）、理论书（图形学），很少有书籍教你如何开发一个45度角地图系统加编辑器的，全靠自己思考，以及看前人的代码，需要时找些网络资料。关键是，可以培养最重要的创造力。
对于算法和设计模式，可以研读下，但是关键还是靠平时如何使用了。新手勉强不来的。
项目管理方面的，就得靠工作经验了，多思考多提意见不要只走流程。