Python 3.1入门教程：从基础到对象与方法

需积分: 10 159 浏览量更新于2024-07-19 收藏 871KB PDF 举报

《动手实践Python：初学者教程介绍》是Loyola University Chicago计算机科学系Andrew N. Harrington博士编著的一本针对Python 3.1版本的教程书籍。该书旨在提供一个全面且实践导向的入门指南，帮助读者快速理解和掌握Python编程基础知识。本书共分为三个章节： **第一章：开始使用Python** - **1.1. 背景**：介绍了Python的历史、用途和在当今计算机科学中的地位，让初学者了解学习Python的重要性和价值。 - **1.2. Python解释器与IDLE（集成开发环境）**：讲解如何安装和使用IDLE，这是Python的基本交互环境，用于编写和测试代码。 - **1.3. 类型与函数概览**：阐述Python的数据类型，如整数、字符串，以及函数的概念和基本用法。 - **1.4. 整数算术**：详细说明Python中的算术运算符和整数操作。 - **1.5-1.8. 字符串处理**：包括字符串的基本概念、输入输出操作，以及字符串的更深入处理。 - **1.9. IDLE编辑器和执行**：指导读者如何使用IDLE进行代码编辑和运行。 - **1.10. 输入与输出**：讲解如何接收用户输入和控制程序输出。 - **1.11-1.12. 自定义函数与变量**：介绍函数定义以及如何利用变量存储数据。 - **1.13-1.14. 字典和序列**：探讨Python中的数据结构，如字典及其查找操作，以及列表和元组等序列类型。 - **1.15. 章节总结**：对本章所学内容进行归纳和回顾。 **第二章：对象和方法** - **2.1. 字符串的进一步探索**：继续深入讨论字符串对象和相关方法。 - **2.2. 类和方法**：介绍类的概念，以及如何创建和使用自定义类。 - **2.3. MadLibs（填空游戏）示例**：通过实例展示面向对象编程的应用，提高学习兴趣。 - **2.4. 图形处理**：涉及使用Python库进行基本图形绘制，如Tkinter模块。 - **2.5. 文件操作**：讲解如何读写文件，管理文件和目录。 - **2.6. 章节总结**：对本章对象和方法相关知识进行总结。 **第三章：更深入的控制流程** - **3.1. 条件语句（if...else）**：深入解析条件控制结构，帮助理解如何基于条件执行不同的代码块。 - **3.2. 循环和元组**：讲解循环结构，包括for循环和while循环，并介绍元组作为另一种序列类型的特点。《动手实践Python》以实践为主，通过逐步引导，让初学者逐步掌握基础语法、数据结构和控制流程，从而为进一步学习和开发项目打下坚实的基础。每个章节都有实际操作和案例分析，有助于读者理解和记忆。此外，本书还遵循Creative Commons Attribution-Noncommercial-Share Alike 3.0 United States License，允许在非商业用途下自由分享和传播，促进了知识的普及。

1.7. PRINT FUNCTION, PART I 16

fred = ’Frederick’

first = fred

first

Now fred, without the quotes, makes sense.

There are more subtleties to assignment and the idea of a variable being a “name for” a value, but we

will worry about them later, in Section 2.4.6. They do not come up if our variables are just numbers and

strings.

Autocompletion: A handy short cut. Python remembers all the variables you have deﬁned at any moment.

This is handy when editing. Without pressing Enter, type into the Shell just

Then hold down the Alt key and press the ’/’ key. This key combination is abbreviated Alt-/. You

should see f autocompleted to be first. This is particularly useful if you have long identiﬁers! You can

press Alt-/ several times if more than one identiﬁer starts with the initial sequence of characters you typed.

If you press Alt-/ again you should see fred. Backspace and edit so you have fi, and then and press Alt-/

again. You should not see fred this time, since it does not start with fi.

1.6.1. Literals and Identiﬁers. Expressions like 27 or ’hello’ are called literals, coming from the

fact that they literally mean exactly what they say. They are distinguished from variables, who value is not

directly determined by their name.

The sequence of characters used to form a variable name (and names for other Python entities later) is

called an identiﬁer. It identiﬁes a Python variable or other entity.

There are some restrictions on the character sequence that make up an identiﬁer:

• The characters must all be letters, digits, or underscores ’_’, and must start with a letter. In

particular, punctuation and blanks are not allowed.

• There are some words that are reserved for special use in Python. You may not use these words

as your own identiﬁers. They are easy to recognize in Idle, because they are automatically colored

orange. For the curious, you may read the full list:

False class finally is return

None continue for lambda try

True def from nonlocal while

and del global not with

as elif if or yield

assert else import pass

break except in raise

There are also identiﬁers that are automatically deﬁned in Python, and that you could redeﬁne, but you

probably should not unless you really know what you are doing! When you start the editor, we will see how

Idle uses color to help you know what identiﬁes are predeﬁned.

Python is case sensitive: The identiﬁers last, LAST, and LaSt are all diﬀerent. Be sure to be consistent.

Using the Alt-/ auto-completion shortcut in Idle helps ensure you are consistent.

What is legal is distinct from what is conventional or good practice or recommended. Meaningful

names for variables are important for the humans who are looking at programs, understanding them,

and revising them. That sometimes means you would like to use a name that is more than one word

long, like price at opening, but blanks are illegal! One poor option is just leaving out the blanks, like

priceatopening. Then it may be hard to ﬁgure out where words split. Two practical options are

• underscore separated: putting underscores (which are legal) in place of the blanks, like price_at_opening.

• using camelcase: omitting spaces and using all lowercase, except capitalizing all words after the

ﬁrst, like priceAtOpening

Use the choice that ﬁts your taste (or the taste or convention of the people you are working with).

1.7. Print Function, Part I

In interactive use of the Python interpreter, you can type an expression and immediately see the result

of its evaluation. This is ﬁne to test out syntax and maybe do simple calculator calculations. In a program

1.9. THE IDLE EDITOR AND EXECUTION 17

run from a ﬁle like the ﬁrst sample program, Python does not display expressions this way. If you want your

program to display something, you can give explicit instructions with the print function. Try in the Shell:

x = 3

y = 5

print(’The sum of’, x, ’plus’, y, ’is’, x+y)

The print function will prints as strings everything in a comma-separated sequence of expressions, and it

will separate the results with single blanks by default. Note that you can mix types: anything that is not

already a string is automatically converted to its string representation.

You can also use it with no parameters:

print()

to just advance to the next line.

1.8. Strings Part II

1.8.1. Triple Quoted String Literals. Strings delimited by one quote character are required to lie

within a single Python line. It is sometimes convenient to have a multi-line string, which can be delimited

with triple quotes: Try typing the following. You will get continuation lines until the closing triple quotes.

Try in the Shell:

sillyTest = ’’’Say,

"I’m in!"

This is line 3’’’

print(sillyTest)

The line structure is preserved in a multi-line string. As you can see, this also allows you to embed both

single and double quote characters!

1.8.2. Escape Codes. Continuing in the Shell with sillyTest, enter just

sillyTest

The answer looks strange! It indicates an alternate way to encode the string internally in Python using escape

codes. Escape codes are embedded inside string literals and start with a backslash character (\). They are

used to embed characters that are either unprintable or have a special syntactic meaning to Python that

you want to suppress. In this example you see the most common ones:

Escape code Meaning

\’ ’

\n newline

\\ \

The newline character indicates further text will appear on a new line when printed. When you use a

print function, you get the actual printed meaning of the escaped coded character.

Predict the result, and try in the Shell:

print(’a\nb\n\nc’)

Did you guess the right number of lines splitting in the right places?

1.9. The Idle Editor and Execution

1.9.1. Loading a Program in the Idle Editor, and Running It. It is time to put longer collections

of instructions together. That is most easily done by creating a text ﬁle and running the Python interpreter

on the ﬁle. Idle simpliﬁes that process.

First you can put an existing ﬁle into an Idle Edit Window. Click on the Idle File menu and select Open.

(Or as you see, you can use the shortcut Ctrl+O. That means holding down the Ctrl key, and pressing the

letter O for Open.) You should get a ﬁle selection dialog. You should have the sample program madlib.py

displayed in the list. Select it and open it. (If you do not see the program, then you either failed to download

the example programs, Section 1.2.1, or you did not start Idle in the proper folder, Section 1.2.4.)

You will see the source code again. Now run this program from inside of Idle: Go to the Run menu of

that Edit window, and select Run Module. Notice the shortcut (F5).

1.9. THE IDLE EDITOR AND EXECUTION 18

If the Shell window does not automatically come to the foreground, select it. You should see a line

saying “RESTART” and then the start of the execution of the Mad Lib program with the cursor waiting for

your entry after the ﬁrst prompt. Finish executing the program. Be sure to type the ﬁnal requested Enter,

so you get back to the interpreter prompt: >>>

Look at the editor window again. You should see that diﬀerent parts of the code have diﬀerent colors.

String literals are likely green. The reserved words def are likely orange. Look at the last two lines, where

the identiﬁer tellStory is black, and the identiﬁer input is likely purple. Only identiﬁers that are not

predeﬁned by Python are black. If you create an identiﬁer name, make sure Idle shows it in black.

1.9.2. A Bug Possible When Restarting Program Execution in Idle. When you execute a

program from the Idle Editor, the interpreter gives a banner saying “RESTART”, meaning that all the

things you deﬁned in any shell session so far are wiped clean and the program you are running starts fresh.

There is one egregious exception to that, that was still present at least in the version of Idle for Python 3.1

in Windows. We will try to demonstrate the bug. (A bug is an error in a program.)

Start running the Mad Lib program again by going to the Editor Window containing madlib.py, and

start running the program again, but do not continue....

You should see a prompt for user input generated by the program. Ignore this prompt and go back to

the Edit Window and start the Mad Lib program again.

If this bug is still present, you should see a diﬀerence in this restart: This time after the RESTART

banner and the interpreter prompt: >>>, which looks innocent enough, but this program should show the

program’s prompt string for input.

The problem only comes up because you interrupted the last execution when user input was being waited

for. The restart was not complete here: The system is still looking for the pending user input from the last

execution.

The ﬁx is simple: Make sure the Interpreter Window is the currently selected window, and press return

to terminate the lost user input. In some circumstances, you may need to press return a second time.

After that the program should start up normally with its prompt.

Watch out for this behavior, and remember the ﬁx.

1.9.3. The Classic First Program . Make sure you have Idle started in your Python directory (in

Windows with the provided Idle shortcut link), where you will store program ﬁles. (Do not start Idle from

the Windows Start Menu!) If you just started Idle now, you may already have a blank Edit Window in

front of you. If not, open a new window by going to the File menu and selecting New Window. This gives

you a rather conventional text editing window with the mouse available, ability to cut and paste, plus a few

special options for Python.

Type (or paste) the following into the editor window:

print(’Hello world!’)

Save the ﬁle with the File menu -> Save, and then enter the ﬁle name hello.py. Python program ﬁles

should always be given a name ending in ".py", and you must enter the .py extension explicitly .

If you look in the editor, you should see that your text is color coded. The editor will color diﬀerent

parts of Python syntax in special colors. (In version 2.4 of Python, the coloring only happens after you save

your ﬁle with the ’.py’ ending.)

Now that you have a complete, saved program, choose Run menu -> Run Module. You should see the

program run in the Python Shell window.

You just wrote and executed a program. Unlike when you use the shell, this code is saved to a ﬁle in

your Python folder. You can open and execute the ﬁle any time you want. (In Idle, use File->Open.)

To the interpreter, a program source ﬁle corresponds to a Python module. We will tend to use the more

general term: a program ﬁle is a module. Note the term from the menu when running the program.

Distinguish program code from Shell text: It is easy to confuse the Shell and the Edit windows. Make

sure you keep them straight. The hello.py program is just the line

print(’Hello world!’)

that you typed into the edit window and saved. When you ran the program in Idle, you saw results in the

Shell. First came the Restart notice, the one-line output from the program saying hello, and a further Shell

prompt:

1.10. INPUT AND OUTPUT 19

>>> ================================ RESTART ========

>>>

Hello world!

>>>

You could also have typed this single printing line directly in the Shell in response to a Shell prompt. When

you see >>>, you could enter the print function and get the exchange between you and the Shell:

>>> print(’Hello world’)

Hello world!

>>>

The three lines above are not a program you could save in a ﬁle and run. This is just an exchange in the

Shell, with its >>> prompts, individual line to execute and the response. Again, just the single line, with no

>>>,

print(’Hello world!’)

entered into the Edit window forms a program you can save and run. We will shortly get to more interesting

many-statement programs, where it is much more convenient to use the Edit window than the Shell!

1.9.4. Program Documentation String. The program above is self evident, and shows how short

and direct a program can be (unlike other languages like Java). Still, right away, get used to documenting

a program. Python has a special feature: If the beginning of a program is just a quoted string, that string

is taken to be the program’s documentation string. Open the example ﬁle hello2.py in the Edit window:

’’’A very simple program,

showing how short a Python program can be!

Authors: ___, ___

’’’

print(’Hello world!’) #This is a stupid comment after the # mark

Most commonly, the initial documentation goes on for several lines, so a multi-line string delimiter is used

(the triple quotes). Just for completeness of illustration in this program, another form of comment is

also shown, a comment that starts with the symbol # and extends to the end of the line. The Python

interpreter completely ignores this form of comment. Such a comment should only be included for better

human understanding. Avoid making comments that do not really aid human understanding. (Do what I

say, not what I did above.) Good introductory comment strings and appropriate names for the parts of your

programs make fewer # symbol comments needed.

Run the program and see the documentation and comment make no diﬀerence in the result.

1.9.5. Screen Layout. Of course you can arrange the windows on your computer screen any way that

you like. A suggestion as you start to use the combination of the editor to write, the shell to run, and the

tutorial to follow along: Make all three mostly visible your computer screen at once. Drag the editor window

to the upper left. Place the Shell window to the lower left, and perhaps reduce its height a bit so there is not

much overlap. If you are looking at the web version of the tutorial on the screen, make it go top to bottom

on the right, but not overlap the Idle windows too much. The web page rendering should generally adapt

to the width pretty well. You can always temporarily maximize the window. Before resizing the browser

window, it is good to look for an unusual phrase on your page, and search for it after resizing, since resizing

can totally mess up your location in the web page.

There is an alternative to maximization for the Idle editor window: It you want it to go top to bottom

of the screen but not widen, you can toggle that state with Alt-2. Play with all this.

1.10. Input and Output

1.10.1. The input Function. The hello program of Section 1.9.3 always does the same thing. This is

not very interesting. Programs are only going to be reused if they can act on a variety of data. One way to

get data is directly from the user. Modify the hello.py program as follows in the editor, and save it from the

File menu with Save As...., using the name hello_you.py.

1.10. INPUT AND OUTPUT 20

person = input(’Enter your name: ’)

print(’Hello’, person)

Run the program. In the Shell you should see

Enter your name:

Follow the instruction (and press Enter). Make sure the typing cursor is in the Shell window, at the end

of this line. After you type your response, you can see that the program has taken in the line you typed.

That is what the built-in function input does: First it prints the string you give as a parameter (in this case

’Enter your name: ’), and then it waits for a line to be typed in, and returns the string of characters

you typed. In the hello_you.py program this value is assigned to the variable person, for use later.

The parameter inside the parentheses after input is important. It is a prompt, prompting you that

keyboard input is expected at that point, and hopefully indicating what is being requested. Without the

prompt, the user would not know what was happening, and the computer would just sit there waiting!

Open the example program, interview.py. Before running it (with any made-up data), see if you can

ﬁgure out what it will do:

’’’Illustrate input and print.’’’

applicant = input("Enter the applicant’s name: ")

interviewer = input("Enter the interviewer’s name: ")

time = input("Enter the appointment time: ")

print(interviewer, "will interview", applicant, "at", time)

The statements are executed in the order they appear in the text of the program: sequentially. This is the

simplest way for the execution of the program to ﬂow. You will see instructions later that alter that natural

ﬂow.

If we want to reload and modify the hello_you.py program to put an exclamation point at the end,

you could try:

person = input(’Enter your name: ’)

print(’Hello’, person, ’!’)

Run it and you see that it is not spaced right. There should be no space after the person’s name, but the

default behavior of the print function is to have each ﬁeld printed separated by a space. There are several

ways to ﬁx this. You should know one. Think about it before going on to the next section. Hint:

1.10.2. Print with Keyword Parameter sep. One way to put punctuation but no space after the

person in hello_you.py is to use the plus operator, +. Another approach is to change the default separatpr

between ﬁelds in the print function. This will introduce a new syntax feature, keyword parameters. The

print function has a keyword parameter named sep. If you leave it out of a call to print, as we have so far,

it is set equal to a space by default. If you add a ﬁnal ﬁeld, sep=”, in the print function in hello_you.py,

you get the following example ﬁle, hello_you2.py:

person = input(’Enter your name: ’)

print(’Hello ’, person, ’!’, sep=’’)

Try the program.

Keyword paramaters must be listed at the end of the parameter list.

1.10.3. Numbers and Strings of Digits. Consider the following problem: Prompt the user for two

numbers, and then print out a sentence stating the sum. For instance if the user entered 2 and 3, you would

print “The sum of 2 and 3 is 5.”

You might imagine a solution like the example ﬁle addition1.py, shown below. There is a problem.

Can you ﬁgure it out before you try it? Hint:

End up running it in any case.

x = input("Enter an integer: ")

y = input("Enter another integer: ")

print(’The sum of ’, x, ’ and ’, y, ’ is ’, x+y, ’.’, sep=’’) # error!

The + operation on strings adds no extra space.

The input function produces values of string type.

剩余138页未读，继续阅读

charlescai88

粉丝: 0
资源: 17

Python 3.1入门教程：从基础到对象与方法

Python SSL Tutorial

Hands-on-PythonTutorial_HandsOn_python_

161204_mastering_the_freertos_real_time_kernel-a_hands- on_tutorial_guide

protoc *.proto --python_out=.

linuxcnc如何配置xenomai

libvirt-python官方文档

推荐Python小白学习教程

python的推荐书籍

github c语言学习

有达芬奇调色教程的视频

最新资源