Python编程入门与实战：从数据科学到网页开发

python

从入门到精通

需积分: 7 34 浏览量更新于2024-07-18 收藏 736KB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

"Dive Into Python" 是一本深入学习Python编程的书籍，涵盖了从入门到精通的全过程。这本书被多所国际知名大学选为计算机入门课程的教材，适合初学者和有一定经验的开发者，用于数据科学、网页开发以及基础设施建设等多领域的应用。在【标题】"Dive Into Python" 中，我们了解到这本书的核心是帮助读者全面掌握Python编程。"Dive Into" 表示深入学习，意味着这本书将带领读者逐步深入Python的世界。【描述】指出，Python是最广泛应用于数据科学领域的编程语言之一，同时也是网页开发和基础建设的重要工具。这表明Python在当前技术领域的重要性，并强调了学习Python的必要性。【标签】"python 从入门到精通" 明确了这本书的目标读者群体，即对Python感兴趣，无论是否有编程基础，都希望通过这本书从零开始，系统地学习和掌握Python。【部分内容】提到了书中的章节，包括： 1. **安装Python**：讲解了如何在不同的操作系统（如Windows、MacOSX、MacOS9、RedHat Linux、Debian GNU/Linux）上安装Python，以及从源代码编译安装，还介绍了Python的交互式 shell。 2. **你的第一个Python程序**：引导读者开始编写Python代码，讲解了函数的声明、文档注释、对象的概念、代码缩进以及模块测试的基本方法。 3. **原生数据类型**：介绍了Python中的基本数据结构，如字典、列表、元组，以及变量声明、字符串格式化、列表映射、列表和字符串的连接与拆分。 4. **反射的力量**：讨论了Python的内省机制，包括可选参数和命名参数的使用、内置函数如`type`、`str`、`dir`的应用，获取对象引用的方法，列表过滤，`and`和`or`的特殊性质，`lambda`函数的使用，以及如何综合运用这些概念。通过以上内容，我们可以预见这本书将全面覆盖Python的基础语法、数据结构、函数使用、面向对象编程以及高级特性。它不仅适用于初学者建立坚实的Python基础，也对有经验的开发者提供了深入理解和提升技能的机会。

资源详情

资源推荐

def buildConnectionString(params):

Note that the keyword def starts the function declaration, followed by the function name, followed by the arguments

in parentheses. Multiple arguments (not shown here) are separated with commas.

Also note that the function doesn't define a return datatype. Python functions do not specify the datatype of their

return value; they don't even specify whether or not they return a value. In fact, every Python function returns a value;

if the function ever executes a return statement, it will return that value, otherwise it will return None, the Python

null value.

In Visual Basic, functions (that return a value) start with function, and subroutines (that do not return a value)

start with sub. There are no subroutines in Python. Everything is a function, all functions return a value (even if it's

None), and all functions start with def.

The argument, params, doesn't specify a datatype. In Python, variables are never explicitly typed. Python figures out

what type a variable is and keeps track of it internally.

In Java, C++, and other statically−typed languages, you must specify the datatype of the function return value and

each function argument. In Python, you never explicitly specify the datatype of anything. Based on what value you

assign, Python keeps track of the datatype internally.

2.2.1. How Python's Datatypes Compare to Other Programming Languages

An erudite reader sent me this explanation of how Python compares to other programming languages:

statically typed language

A language in which types are fixed at compile time. Most statically typed languages enforce this by requiring

you to declare all variables with their datatypes before using them. Java and C are statically typed languages.

dynamically typed language

A language in which types are discovered at execution time; the opposite of statically typed. VBScript and

Python are dynamically typed, because they figure out what type a variable is when you first assign it a value.

strongly typed language

A language in which types are always enforced. Java and Python are strongly typed. If you have an integer,

you can't treat it like a string without explicitly converting it.

weakly typed language

A language in which types may be ignored; the opposite of strongly typed. VBScript is weakly typed. In

VBScript, you can concatenate the string '12' and the integer 3 to get the string '123', then treat that as

the integer 123, all without any explicit conversion.

So Python is both dynamically typed (because it doesn't use explicit datatype declarations) and strongly typed (because

once a variable has a datatype, it actually matters).

2.3. Documenting Functions

You can document a Python function by giving it a doc string.

Example 2.2. Defining the buildConnectionString Function's doc string

def buildConnectionString(params):

"""Build a connection string from a dictionary of parameters.

Dive Into Python 10

Returns string."""

Triple quotes signify a multi−line string. Everything between the start and end quotes is part of a single string,

including carriage returns and other quote characters. You can use them anywhere, but you'll see them most often used

when defining a doc string.

Triple quotes are also an easy way to define a string with both single and double quotes, like qq/.../ in Perl.

Everything between the triple quotes is the function's doc string, which documents what the function does. A

doc string, if it exists, must be the first thing defined in a function (that is, the first thing after the colon). You

don't technically need to give your function a doc string, but you always should. I know you've heard this in

every programming class you've ever taken, but Python gives you an added incentive: the doc string is available

at runtime as an attribute of the function.

Many Python IDEs use the doc string to provide context−sensitive documentation, so that when you type a

function name, its doc string appears as a tooltip. This can be incredibly helpful, but it's only as good as the doc

strings you write.

Further Reading on Documenting Functions

PEP 257 (http://www.python.org/peps/pep−0257.html) defines doc string conventions.•

Python Style Guide (http://www.python.org/doc/essays/styleguide.html) discusses how to write a good doc

string.

•

Python Tutorial (http://www.python.org/doc/current/tut/tut.html) discusses conventions for spacing in doc

strings (http://www.python.org/doc/current/tut/node6.html#SECTION006750000000000000000).

•

2.4. Everything Is an Object

In case you missed it, I just said that Python functions have attributes, and that those attributes are available at

runtime.

A function, like everything else in Python, is an object.

Open your favorite Python IDE and follow along:

Example 2.3. Accessing the buildConnectionString Function's doc string

>>> import odbchelper

>>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}

>>> print odbchelper.buildConnectionString(params)

server=mpilgrim;uid=sa;database=master;pwd=secret

>>> print odbchelper.buildConnectionString.__doc__

Build a connection string from a dictionary

Returns string.

The first line imports the odbchelper program as a module −− a chunk of code that you can use

interactively, or from a larger Python program. (You'll see examples of multi−module Python programs in

Chapter 4.) Once you import a module, you can reference any of its public functions, classes, or attributes.

Modules can do this to access functionality in other modules, and you can do it in the IDE too. This is an

important concept, and you'll talk more about it later.

Dive Into Python 11

When you want to use functions defined in imported modules, you need to include the module name. So you

can't just say buildConnectionString; it must be odbchelper.buildConnectionString. If

you've used classes in Java, this should feel vaguely familiar.

Instead of calling the function as you would expect to, you asked for one of the function's attributes, __doc__.

import in Python is like require in Perl. Once you import a Python module, you access its functions with

module.function; once you require a Perl module, you access its functions with module::function.

2.4.1. The Import Search Path

Before you go any further, I want to briefly mention the library search path. Python looks in several places when you

try to import a module. Specifically, it looks in all the directories defined in sys.path. This is just a list, and you

can easily view it or modify it with standard list methods. (You'll learn more about lists later in this chapter.)

Example 2.4. Import Search Path

>>> import sys

>>> sys.path

['', '/usr/local/lib/python2.2', '/usr/local/lib/python2.2/plat−linux2',

'/usr/local/lib/python2.2/lib−dynload', '/usr/local/lib/python2.2/site−packages',

'/usr/local/lib/python2.2/site−packages/PIL', '/usr/local/lib/python2.2/site−packages/piddle']

>>> sys

>>> sys.path.append('/my/new/path')

Importing the sys module makes all of its functions and attributes available.

sys.path is a list of directory names that constitute the current search path. (Yours will look different,

depending on your operating system, what version of Python you're running, and where it was originally

installed.) Python will look through these directories (in this order) for a .py file matching the module name

you're trying to import.

Actually, I lied; the truth is more complicated than that, because not all modules are stored as .py files. Some,

like the sys module, are "built−in modules"; they are actually baked right into Python itself. Built−in modules

behave just like regular modules, but their Python source code is not available, because they are not written in

Python! (The sys module is written in C.)

You can add a new directory to Python's search path at runtime by appending the directory name to

sys.path, and then Python will look in that directory as well, whenever you try to import a module. The

effect lasts as long as Python is running. (You'll talk more about append and other list methods in Chapter 3.)

2.4.2. What's an Object?

Everything in Python is an object, and almost everything has attributes and methods. All functions have a built−in

attribute __doc__, which returns the doc string defined in the function's source code. The sys module is an

object which has (among other things) an attribute called path. And so forth.

Still, this begs the question. What is an object? Different programming languages define "object" in different ways. In

some, it means that all objects must have attributes and methods; in others, it means that all objects are subclassable.

In Python, the definition is looser; some objects have neither attributes nor methods (more on this in Chapter 3), and

not all objects are subclassable (more on this in Chapter 5). But everything is an object in the sense that it can be

assigned to a variable or passed as an argument to a function (more in this in Chapter 4).

This is so important that I'm going to repeat it in case you missed it the first few times: everything in Python is an

object. Strings are objects. Lists are objects. Functions are objects. Even modules are objects.

Dive Into Python 12

Python编程入门与实战：从数据科学到网页开发

Dive into python

dive into python (深入python)中文教程

Dive Into Python 3

DIVE INTO PYTHON

diveintopython

DiveIntoPython

dive into python

Dive Into Python

Diveintopython

Dive Into Python中文教程

dive-into-python3 （英文版）+深入python3（中文版）

深入python 3 （DIVE INTO PYTHON 3）最新版，加源代码

Dive Into Python 3 中文版

Dive Into Python 3 无水印pdf

《Dive Into Python》

《Dive Into Python 3中文版》PDF

Dive Into Python 2 中文版

dive into python_代码_教程

dive into python3 (中文版)

最新资源