Python游戏开发入门指南：从基础到高级

需积分: 9 94 浏览量更新于2024-07-18 收藏 4.87MB PDF 举报

"Python游戏开发基础知识" Python游戏开发是一门综合性很强的学科，它涵盖了多个领域，包括数学、物理、图形学、用户界面、人工智能等。为了学习Python游戏开发，需要具备一定的数学基础和编程基础。 1. Python基础知识 Python是一种高级编程语言，具有易于学习、灵活、跨平台等特点。Python游戏开发首先需要具备Python基础知识，包括变量、数据类型、运算符、控制结构、函数、模块等。 2. Pygame库的使用 Pygame是一个跨平台的Python游戏开发库，提供了一个简单易用的接口来创建游戏。使用Pygame可以创建2D游戏，包括图形、音效、用户输入等元素。 3. 图形学基础知识图形学是游戏开发的基础之一，包括点、线、面、纹理、光照等概念。Python游戏开发中需要具备图形学基础知识，以便创建游戏中的视觉效果。 4. 用户界面设计用户界面设计是游戏开发的重要组成部分，包括菜单、按钮、文本框、图形等元素。Python游戏开发中需要具备用户界面设计基础知识，以便创建游戏中的交互界面。 5. 人工智能基础知识人工智能是游戏开发的高级技术之一，包括机器学习、自然语言处理、计算机视觉等领域。Python游戏开发中需要具备人工智能基础知识，以便创建游戏中的智能行为。 6. 游戏开发流程游戏开发流程包括游戏设计、资源创建、编程、测试、发布等阶段。Python游戏开发中需要具备游戏开发流程基础知识，以便更好地组织游戏开发工作。 7. OpenGL基础知识 OpenGL是一个跨平台的图形API，提供了一个强大的接口来创建3D图形。Python游戏开发中需要具备OpenGL基础知识，以便创建游戏中的3D视觉效果。 8. 游戏对象管理游戏对象管理是游戏开发的重要组成部分，包括游戏对象的创建、更新、销毁等过程。Python游戏开发中需要具备游戏对象管理基础知识，以便更好地管理游戏中的对象。 9. 游戏打包和发布游戏打包和发布是游戏开发的最后阶段，包括游戏的打包、测试、发布等过程。Python游戏开发中需要具备游戏打包和发布基础知识，以便将游戏发布到不同平台上。 Python游戏开发需要具备多方面的知识，包括Python基础知识、图形学基础知识、用户界面设计基础知识、人工智能基础知识、游戏开发流程基础知识、OpenGL基础知识、游戏对象管理基础知识、游戏打包和发布基础知识等。

CHAPTER 1 ■ INTRODUCING PYTHON

Lists support a number of operators that work in a similar way to strings. Let’s look at slicing and

indexing, which you should find very familiar:

>>> my_list[2]

'wasabi'

>>> my_list[-1]

'sake'

The first line returns the string at offset 2, which is the third slot in our shopping list. Just like strings, the

first item in a list is always 0. The second line uses negative indexing, and just like strings [-1] returns the

last item.

Slicing lists works similar to slicing strings, with the exception that they return a new list rather than a

string. Let’s slice our shopping list into two portions:

>>> my_list[:2]

['chopsticks', 'dark soy sauce']

>>> my_list[2:]

['wasabi', 'fugu', 'sake']

>>>

In the first slice we have asked Python to give us all the items from the beginning of the list to offset 2;

in the second slice we have asked for everything from offset 2 to the end of the list. List offsets work just like

string offsets, so try to think of them as the spaces between objects in the list and not the objects themselves.

Therefore, offset 0 is before the first item and offset 1 is after the first item and before the second.

You can also add lists together with the + operator. When you add lists together, it creates a single list

containing the items from both lists. Let’s create a new list and add it to our shopping list:

>>> my_list2 = ['ramen', 'shiitake mushrooms']

>>> my_list += my_list2

>>> my_list

['chopsticks', 'dark soy sauce', 'wasabi', 'fugu', 'sake', 'ramen', 

'shiitake mushrooms']

The first line creates a new list of strings called my_list2. We have created this second list slightly

differently from the first; instead of creating a blank list and adding items to it one at a time, we have created

a list with two items already in there. The second line uses the += operator, which is useful shorthand:

my_list+=my_list2 is the same as my_list=my_list+my_list2, which has the effect of adding the two lists

together and storing the result back in my_list.

List Methods

Along with these operators, lists support a number of methods. Let’s use the sort method to sort our

shopping list into alphabetical order:

>>> my_list.sort()

>>> my_list

['chopsticks', 'dark soy sauce', 'fugu', 'ramen', 'sake', 

'shiitake mushrooms', 'wasabi']

The sort method sorts the contents of the list. The order depends on the contents of the list, but for a

list of strings the sort is in alphabetical order.

CHAPTER 1 ■ INTRODUCING PYTHON

Here we have created a tuple with two strings containing the area code and number of our fugu

takeaway. To prove a tuple is immutable, let’s try appending an item to it:

>>> my_tuple.append('ramen')

Traceback (most recent call last):

File "<interactive input>", line 1, in ?

AttributeError: 'tuple' object has no attribute 'append'

Python has thrown an AttributeError exception, letting you know that tuples do not support append.

You will get similar results if you try to do anything that modifies the tuple. Tuples do support all the

indexing and slicing operators, however, because these operators don’t modify the tuple.

>>> my_tuple[0]

'555'

>>> my_tuple[1]

'EATFUGU'

Unpacking

Because tuples are often used to pass around group values, Python gives you a simple way of extracting them

called unpacking. Let’s unpack our tuple into two variables: one for the area code and one for the number.

>>> my_tuple=('555', 'EATFUGU')

>>> area_code, number = my_tuple

>>> area_code

'555'

>>> number

'EATFUGU'

Here you can see that in a single line, Python has unpacked the two parts of our tuple into two separate

values. Unpacking actually works for lists and other Python objects, but you will most often use it with tuples.

Another way to extract the values in a tuple is to convert it into a list. You can do this by constructing

a list with the tuple as a parameter—for example, list(my_tuple) returns the list equivalent, which is

['555', 'EATFUGU']. You can also do the reverse and create a tuple by calling tuple on a list— for example,

tuple(['555', 'EATFUGU']) returns our original tuple.

You will learn the best places to use tuples over lists in the following chapters; for now use the rule of

thumb that you should use a tuple if you never need to modify the contents.

■ Note Creating a tuple with one or zero items is a little different from lists. This is because Python also

uses parentheses to define the priority in math-like expressions. To define a tuple with just one item, add a

comma after the item; to define an empty tuple, just include the comma by itself in parentheses. For example,

('ramen',) is a tuple with one item, and (,) is an empty tuple.

CHAPTER 1 ■ INTRODUCING PYTHON

Dictionaries

The final collection type we are going to look at is the dictionary. The previous collections we looked at

have all been sequence collections, because the values are in a sequence from first to last and you access

them by their position within the list. Dictionaries are mapping collections because they map one piece

of information to another. We could use a dictionary to store the prices of our shopping list by mapping

the name of the food item to its price. Let’s say that fugu costs $100 and ramen costs $5; we can create a

dictionary that holds this information as follows:

>>> my_dictionary={'ramen': 5.0, 'fugu': 100.0}

The curly braces create a dictionary. Inside the braces we have the string 'ramen' followed by a colon,

then the number 5.0 (price in dollars). This tells Python that the string maps to the number; in other words,

we can look up the price if we have the name of the food item. Multiple items in a dictionary are separated

with a comma; in this example we have a second item that maps 'fugu' to the value 100.0.

To retrieve that information, we use the square brackets ([]) operator again, passing in the key we want

to search for (in this case the key is either fugu or ramen). The dictionary returns the value associated with

the key—the price of the item. Let’s look up our two keys:

>>> my_dictionary['fugu']

100.0

>>> my_dictionary['ramen']

5.0

You can also add new items to the dictionary by assigning new values to it:

>>> my_dictionary['chopsticks']=7.50

>>> my_dictionary['sake']=19.95

>>> my_dictionary

{'sake': 19.0, 'ramen': 5.0, 'chopsticks': 7.5, 'fugu': 100.0}

Here we have added two new items to the dictionary. You may have noticed that when Python displays

the list for us, the items are in a different order than the way we originally created it. This is because

dictionaries don’t have any notion of order for keys in a dictionary and what you see displayed is in no

particular order. The important thing is that Python remembers what key maps to what value—which it does

very well!

Loops

A loop is a way of running through a piece of code more than once. Loops are fundamental in programming

languages, and you will find that almost every line of code you write in a game is inside some kind of loop.

Like many other programming languages, Python has two types of loop to handle all your looping needs: the

while loop and the for loop.

CHAPTER 1 ■ INTRODUCING PYTHON

While Loops

A while loop is used when you repeat a piece of code only when, or while, a condition is true. Let’s use

a simple while loop to display the numbers from 1 to 5. We’ll start by entering the following lines in the

interpreter:

>>> count=1

>>> while count<=5:

...

When you hit Enter after the second line, you will notice that instead of the usual Python prompt you

now see three periods (...). This is because the colon at the end of the line indicates that there is more code

to follow. In the case of a while loop, it is the code that we want to be repeated.

All languages need some way to mark the beginning and end of code blocks. Some use symbols like

curly braces ({ }), and others use words like do and end. Python does things slightly differently and uses

indentation to define blocks of code. To tell Python that a line of code is part of the block and not the rest of

the code, insert a tab before the line (by pressing the Tab key):

... print(count)

... count+=1

■ Note On some systems you may find that a tab is automatically inserted on the first line of a block. This

can be convenient if there is a lot of code in a block. Delete the tab and press Enter as normal to end the block.

Press Enter twice after the last line; the blank line tells the interpreter that you have finished entering

the code block. The while loop now runs and displays the numbers 1 through 5. So how does this work? Well,

after the while statement is a condition (count<=5), which can be read as “Is count less than or equal to 5?”

The first time Python encounters the while loop, count is 1, which satisfies our condition of being less than

or equal to 5—so Python runs the code block. The two lines in the code block first print the value of count,

then add one to it. The second time around, count is 2, which also satisfies the condition and we go around

the loop again. Eventually count becomes 6, which is definitely not less than or equal to 5, and this time

Python skips the code block.

Less than or equal to (<=) is just one comparison operator. See Table1-2 for others you can use.

Table 1-2. Comparison Operators

Operator Description

< Less than

<= Less than or equal to

> Greater than

>= Greater than or equal to

== Equal to

!= Not equal to

www.allitebooks.com

剩余289页未读，继续阅读

kernelkoder

粉丝: 57
资源: 317

Python游戏开发入门指南：从基础到高级

Beginning Python Games Development(2nd).pdf 2015第2版

Beginning Python Games Development(Apress,2ed,2015)

Beginning Python Games Development second edition

Beginning Python Games Development, Second Edition.zip

英文原版-Beginning Python Visualization 1st Edition

Beginning Python From Novice to Professional Second Edition

Beginning iPhone Games Development

beginning python from novice to professional second edition 2008.pdf

Beginning Android Games, 2nd Edition

Beginning Swift Games Development for iOS

最新资源