Python学习笔记1

python 介绍

python的创始人为吉多·范罗苏姆(Guido van Rossum)。1989年的圣诞节期间,吉多·范罗苏姆为了在阿姆斯特丹打发时间,决心开发一个新的脚本解释程序,作为ABC语言的一种继承。

Python 是一款易于学习且功能强大的编程语言。 它具有高效率的数据结构,能够简单又有效地实现面向对象编程。Python 简洁的语法与动态输入之特性,加之其解释性语言的本质,使得它成为一种在多种领域与绝大多数平台都能进行脚本编写与应用快速开发工作的理想语言。

Hello World 程序

案例(保存为 hello.py):

1
2
3
#!/usr/bin/env python3

print ("Hello World!")

给予可执行权限chmod +x HelloWorld.py
这样执行: ./HelloWorld.py 即可

变量

如果只使用字面常量很快就会让人感到无聊——我们需要一些能够存储任何信息并且也能操纵它们的方式。这便是 变量(Veriables) 登场的时刻。正如其名字所述那般,变量的值是可以变化的,也就是说,你可以用变量来存储任何东西。变量只是你的计算机内存中用以存储信息的一部分。与文字常量不同,你需要通过一些方式来访问这些变量,因此,你需要为它们命名。

标识符命名

变量是标识符的一个例子。标识符(Identifiers) 是为 某些东西 提供的给定名称。在你命名标识符时,你需要遵守以下规则:

第一个字符必须是字母表中的字母(大写 ASCII 字符或小写 ASCII 字符或 Unicode 字符)或下划线(_)。
标识符的其它部分可以由字符(大写 ASCII 字符或小写 ASCII 字符或 Unicode 字符)、下划线(_)、数字(0~9)组成。
标识符名称区分大小写。例如,myname 和 myName 并不等同。要注意到前者是小写字母 n 而后者是大写字母 N。
有效 的标识符名称可以是 i 或 name_2_3 ,无效 的标识符名称可能是 2things,this is spaced out,my-name 和 >a1b2_c3。

用户输入

1
2
3
4
#!/usr/bin/env python3

name = input("What is your name?")
print ("Hello " + name )

输入密码时,如果想要不可见,需要利用getpass 模块中的 getpass方法,即:

1
2
3
4
5
6
7
8
9
#!/usr/bin/env python3

import getpass

# 将用户输入的内容赋值给 name 变量
pwd = getpass.getpass("请输入密码:")

# 打印输入的内容
print(pwd)

函数

函数(Functions)是指可重复使用的程序片段。它们允许你为某个代码块赋予名字,允许你通过这一特殊的名字在你的程序任何地方来运行代码块,并可重复任何次数。这就是所谓的调用(Calling)函数。我们已经使用过了许多内置的函数,例如 len 和 range。

函数概念可能是在任何复杂的软件(无论使用的是何种编程语言)中最重要的构建块,所以我们接下来将在本章中探讨有关函数的各个方面。

函数可以通过关键字 def 来定义。这一关键字后跟一个函数的标识符名称,再跟一对圆括号,其中可以包括一些变量的名称,再以冒号结尾,结束这一行。随后而来的语句块是函数的一部分。下面的案例将会展示出这其实非常简单:

案例(保存为 function1.py):

1
2
3
4
5
6
7
8
9
#!/usr/bin/env python3

def say_hello():
# 该块属于这一函数
print('hello world')
# 函数结束

say_hello() # 调用函数
say_hello() # 再次调用函数
1
2
3
4
5
输出:

$ python3 function1.py
hello world
hello world

它是如何工作的

我们以上文解释过的方式定义名为 say_hello 的函数。这个函数不使用参数,因此在括号中没有声明变量。函数的参数只是输入到函数之中,以便我可以传递不同的值给它,并获得相应的结果。

要注意到我们可以两次调用相同的函数,这意味着我们不必重新把代码再写一次。

函数参数

函数可以获取参数,这个参数的值由你所提供,借此,函数便可以利用这些值来做一些事情。这些参数与变量类似,这些变量的值在我们调用函数时已被定义,且在函数运行时均已赋值完成。

函数中的参数通过将其放置在用以定义函数的一对圆括号中指定,并通过逗号予以分隔。当我们调用函数时,我们以同样的形式提供需要的值。要注意在此使用的术语——在定义函数时给定的名称称作“形参”(Parameters),在调用函数时你所提供给函数的值称作“实参”(Arguments)。

案例(保存为 function_param.py):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#!/usr/bin/env python3

def print_max(a, b):
if a > b:
print(a, 'is maximum')
elif a == b:
print(a, 'is equal to', b)
else:
print(b, 'is maximum')

# 直接传递字面值
print_max(3, 4)

x = 5
y = 7

# 以参数的形式传递变量
print_max(x, y)

输出:

1
2
3
$ python function_param.py
4 is maximum
7 is maximum

它是如何工作的

在这里,我们将函数命名为 print_max 并使用两个参数分别称作 a 和 b。我们使用一个简单的 if…else 语句来找出更大的那个数,并将它打印出来。

第一次调用函数 print_max 时,我们以实参的形式直接向函数提供这一数字。在第二次调用时,我们将变量作为实参来调用函数。print_max(x, y) 将使得实参 x 的值将被赋值给形参 a,而实参 y 的值将被赋值给形参 b。在两次调用中,print_max 都以相同的方式工作。

局部变量

当你在一个函数的定义中声明变量时,它们不会以任何方式与身处函数之外但具有相同名称的变量产生关系,也就是说,这些变量名只存在于函数这一局部(Local)。这被称为变量的作用域(Scope)。所有变量的作用域是它们被定义的块,从定义它们的名字的定义点开始。

案例(保存为 function_local.py):

1
2
3
4
5
6
7
8
9
10
11
12
13
#!/usr/bin/env python3

x = 50


def func(x):
print('x is', x)
x = 2
print('Changed local x to', x)


func(x)
print('x is still', x)

输出:

1
2
3
4
$ python function_local.py
x is 50
Changed local x to 2
x is still 50

它是如何工作的

当我们第一次打印出存在于函数块的第一行的名为 x 的值时,Python 使用的是在函数声明之上的主代码块中声明的这一参数的值。

接着,我们将值 2 赋值给 x。x 是我们这一函数的局部变量。因此,当我们改变函数中 x 的值的时候,主代码块中的 x 则不会受到影响。

随着最后一句 print 语句,我们展示出主代码块中定义的 x 的值,由此确认它实际上不受先前调用的函数中的局部变量的影响。

global 语句

如果你想给一个在程序顶层的变量赋值(也就是说它不存在于任何作用域中,无论是函数还是类),那么你必须告诉 Python 这一变量并非局部的,而是全局(Global)的。我们需要通过 global 语句来完成这件事。因为在不使用 global 语句的情况下,不可能为一个定义于函数之外的变量赋值。

你可以使用定义于函数之外的变量的值(假设函数中没有具有相同名字的变量)。然而,这种方式不会受到鼓励而且应该避免,因为它对于程序的读者来说是含糊不清的,无法弄清楚变量的定义究竟在哪。而通过使用 global 语句便可清楚看出这一变量是在最外边的代码块中定义的。

案例(保存为 function_global.py):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#!/usr/bin/env python3

x = 50


def func():
global x

print('x is', x)
x = 2
print('Changed global x to', x)


func()
print('Value of x is', x)

输出:

1
2
3
4
$ python function_global.py
x is 50
Changed global x to 2
Value of x is 2

它是如何工作的

global 语句用以声明 x 是一个全局变量——因此,当我们在函数中为 x 进行赋值时,这一改动将影响到我们在主代码块中使用的 x 的值。

你可以在同一句 global 语句中指定不止一个的全局变量,例如 global x, y, z。

默认参数值

对于一些函数来说,你可能为希望使一些参数可选并使用默认的值,以避免用户不想为他们提供值的情况。默认参数值可以有效帮助解决这一情况。你可以通过在函数定义时附加一个赋值运算符(=)来为参数指定默认参数值。

要注意到,默认参数值应该是常数。更确切地说,默认参数值应该是不可变的——这将在后面的章节中予以更详细的解释。就目前来说,只要记住就行了。

案例(保存为 function_default.py):

1
2
3
4
5
6
7
#!/usr/bin/env python3

def say(message, times=1):
print(message * times)

say('Hello')
say('World', 5)

输出:

1
2
3
$ python function_default.py
Hello
WorldWorldWorldWorldWorld

它是如何工作的

名为 say 的函数用以按照给定的次数打印一串字符串。如果我们没有提供一个数值,则将按照默认设置,只打印一次字符串。我们通过为参数 times 指定默认参数值 1 来实现这一点。

在第一次使用 say 时,我们只提供字符串因而函数只会将这个字符串打印一次。在第二次使用 say 时,我们既提供了字符串,同时也提供了一个参数 5,声明我们希望说(Say)这个字符串五次。

注意

只有那些位于参数列表末尾的参数才能被赋予默认参数值,意即在函数的参数列表中拥有默认参数值的参数不能位于没有默认参数值的参数之前。

这是因为值是按参数所处的位置依次分配的。举例来说,def func(a, b=5) 是有效的,但 def func(a=5, b) 是无效的。

关键字参数

如果你有一些具有许多参数的函数,而你又希望只对其中的一些进行指定,那么你可以通过命名它们来给这些参数赋值——这就是关键字参数(Keyword Arguments)——我们使用命名(关键字)而非位置(一直以来我们所使用的方式)来指定函数中的参数。

这样做有两大优点——其一,我们不再需要考虑参数的顺序,函数的使用将更加容易。其二,我们可以只对那些我们希望赋予的参数以赋值,只要其它的参数都具有默认参数值。

案例(保存为 function_keyword.py):

1
2
3
4
5
6
7
8
#!/usr/bin/env python3

def func(a, b=5, c=10):
print('a is', a, 'and b is', b, 'and c is', c)

func(3, 7)
func(25, c=24)
func(c=50, a=100)

输出:

1
2
3
4
$ python function_keyword.py
a is 3 and b is 7 and c is 10
a is 25 and b is 5 and c is 24
a is 100 and b is 5 and c is 50

它是如何工作的

名为 func 的函数有一个没有默认参数值的参数,后跟两个各自带有默认参数值的参数。

在第一次调用函数时,func(3, 7),参数 a 获得了值 3,参数 b 获得了值 7,而 c 获得了默认参数值 10。

在第二次调用函数时,func(25, c=24),由于其所处的位置,变量 a 首先获得了值 25。然后,由于命名——即关键字参数——指定,变量 c 获得了值 24。变量 b 获得默认参数值 5。

在第三次调用函数时,func(c=50, a=100),我们全部使用关键字参数来指定值。在这里要注意到,尽管 a 在 c 之前定义,但我们还是我们在变量 a 之前指定了变量 c。

可变参数

有时你可能想定义的函数里面能够有任意数量的变量,也就是参数数量是可变的,这可以通过使用星号来实现(将下方案例保存为 function_varargs.py):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/usr/bin/env python3

def total(a=5, *numbers, **phonebook):
print('a', a)

#遍历元组中的所有项目
for single_item in numbers:
print('single_item', single_item)

#遍历字典中的所有项目
for first_part, second_part in phonebook.items():
print(first_part,second_part)

print(total(10,1,2,3,Jack=1123,John=2231,Inge=1560))

输出:

1
2
3
4
5
6
7
8
9
$ python function_varargs.py
a 10
single_item 1
single_item 2
single_item 3
Inge 1560
John 2231
Jack 1123
None

它是如何工作的

当我们声明一个诸如 *param 的星号参数时,从此处开始直到结束的所有位置参数(Positional Arguments)都将被收集并汇集成一个称为“param”的元组(Tuple)。

类似地,当我们声明一个诸如 **param 的双星号参数时,从此处开始直至结束的所有关键字参数都将被收集并汇集成一个名为 param 的字典(Dictionary)。

我们将在后面的章节探索有关元组与字典的更多内容。

return 语句

return 语句用于从函数中返回,也就是中断函数。我们也可以选择在中断函数时从函数中返回一个值。

案例(保存为 function_return.py):

1
2
3
4
5
6
7
8
9
10
11
#!/usr/bin/env python3

def maximum(x, y):
if x > y:
return x
elif x == y:
return 'The numbers are equal'
else:
return y

print(maximum(2, 3))

输出:

1
2
$ python function_return.py
3

它是如何工作的

maximum 函数将会返回参数中的最大值,在本例中是提供给函数的数值。它使用一套简单的 if…else 语句来找到较大的那个值并将其返回。

要注意到如果 return 语句没有搭配任何一个值则代表着 返回 None。None 在 Python 中一个特殊的类型,代表着虚无。举个例子, 它用于指示一个变量没有值,如果有值则它的值便是 None(虚无)。

每一个函数都在其末尾隐含了一句 return None,除非你写了你自己的 return 语句。你可以运行 print(some_function()),其中 some_function 函数不使用 return 语句,就像这样:

1
2
def some_function():
pass

Python 中的 pass 语句用于指示一个没有内容的语句块。

提示:有一个名为 max 的内置函数已经实现了“找到最大数”这一功能,所以尽可能地使用这一内置函数。

DocStrings

Python 有一个甚是优美的功能称作文档字符串(Documentation Strings),在称呼它时通常会使用另一个短一些的名字docstrings。DocStrings 是一款你应当使用的重要工具,它能够帮助你更好地记录程序并让其更加易于理解。令人惊叹的是,当程序实际运行时,我们甚至可以通过一个函数来获取文档!

案例(保存为 function_docstring.py):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#!/usr/bin/env python3

def print_max(x, y):
'''Prints the maximum of two numbers.打印两个数值中的最大数。

The two values must be integers.这两个数都应该是整数'''
# 如果可能,将其转换至整数类型
x = int(x)
y = int(y)

if x > y:
print(x, 'is maximum')
else:
print(y, 'is maximum')

print_max(3, 5)
print(print_max.__doc__)

输出:

1
2
3
4
5
$ python function_docstring.py
5 is maximum
Prints the maximum of two numbers.

The two values must be integers.

它是如何工作的

函数的第一行逻辑行中的字符串是该函数的 文档字符串(DocString)。这里要注意文档字符串也适用于后面相关章节将提到的模块(Modules)与类(Class) 。

该文档字符串所约定的是一串多行字符串,其中第一行以某一大写字母开始,以句号结束。第二行为空行,后跟的第三行开始是任何详细的解释说明。5在此强烈建议你在你所有重要功能的所有文档字符串中都遵循这一约定。

我们可以通过使用函数的 doc(注意其中的双下划綫)属性(属于函数的名称)来获取函数 print_max 的文档字符串属性。只消记住 Python 将所有东西都视为一个对象,这其中自然包括函数。我们将在后面的类(Class)章节讨论有关对象的更多细节。

如果你曾使用过 Python 的 help() 函数,那么你应该已经了解了文档字符串的用途了。它所做的便是获取函数的 doc 属性并以一种整洁的方式将其呈现给你。你可以在上方的函数中尝试一下——只需在程序中包含 help(print_max) 就行了。要记住你可以通过按下 q 键来退出 help。

自动化工具可以以这种方式检索你的程序中的文档。因此,我强烈推荐你为你编写的所有重要的函数配以文档字符串。你的 Python 发行版中附带的 pydoc 命令与 help() 使用文档字符串的方式类似。

模块

在上一章,你已经了解了如何在你的程序中通过定义一次函数工作来重用代码。那么如果你想在你所编写的别的程序中重用一些函数的话,应该怎么办?正如你可能想象到的那样,答案是模块(Modules)。

编写模块有很多种方法,其中最简单的一种便是创建一个包含函数与变量、以 .py 为后缀的文件。

另一种方法是使用撰写 Python 解释器本身的本地语言来编写模块。举例来说,你可以使用 C 语言来撰写 Python 模块,并且在编译后,你可以通过标准 Python 解释器在你的 Python 代码中使用它们。

一个模块可以被其它程序导入并运用其功能。我们在使用 Python 标准库的功能时也同样如此。首先,我们要了解如何使用标准库模块。

案例 (保存为 module_using_sys.py):

1
2
3
4
5
6
7
8
9
#!/usr/bin/env python3

import sys

print('The command line arguments are:')
for i in sys.argv:
print(i)

print('\n\nThe PYTHONPATH is', sys.path, '\n')

输出:

1
2
3
4
5
6
7
8
9
10
11
12
$ python module_using_sys.py we are arguments
The command line arguments are:
module_using_sys.py
we
are
arguments


The PYTHONPATH is ['/tmp/py',
# many entries here, not shown here
'/Library/Python/2.7/site-packages',
'/usr/local/lib/python2.7/site-packages']

它是如何工作的

首先,我们通过 import 语句导入 sys 模块。基本上,这句代码将转化为我们告诉 Python 我们希望使用这一模块。sys 模块包含了与 Python 解释器及其环境相关的功能,也就是所谓的系统功能(system)。

当 Python 运行 import sys 这一语句时,它会开始寻找 sys 模块。在这一案例中,由于其是一个内置模块,因此 Python 知道应该在哪里找到它。

如果它不是一个已编译好的模块,即用 Python 编写的模块,那么 Python 解释器将从它的 sys.path 变量所提供的目录中进行搜索。如果找到了对应模块,则该模块中的语句将在开始运行,并能够为你所使用。在这里需要注意的是,初始化工作只需在我们第一次导入模块时完成。

sys 模块中的 argv 变量通过使用点号予以指明,也就是 sys.argv 这样的形式。它清晰地表明了这一名称是 sys 模块的一部分。这一处理方式的另一个优点是这个名称不会与你程序中的其它任何一个 argv 变量冲突。

sys.argv 变量是一系列字符串的列表(List)(列表将在后面的章节予以详细解释)。具体而言,sys.argv 包含了命令行参数(Command Line Arguments)这一列表,也就是使用命令行传递给你的程序的参数。

如果你正在使用一款 IDE 来编写并运行这些程序,请在程序菜单中寻找相关指定命令行参数的选项。

在这里,当我们运行 python module_using_sys.py we are arguments 时,我们通过 python 命令来运行 module_using_sys.py 模块,后面的内容则是传递给程序的参数。 Python 将命令行参数存储在 sys.argv 变量中供我们使用。

在这里要记住的是,运行的脚本名称在 sys.argv 的列表中总会位列第一。因此,在这一案例中我们将会有如下对应关系:’module_using_sys.py’ 对应 sys.argv[0],’we’ 对应 sys.argv[1],’are’ 对应 sys.argv[2],’arguments’ 对应 sys.argv[3]。要注意到 Python 从 0 开始计数,而不是 1。

sys.path 内包含了导入模块的字典名称列表。你能观察到 sys.path 的第一段字符串是空的——这一空字符串代表当前目录也是 sys.path 的一部分,它与 PYTHONPATH 环境“储在 sys.argv 变量中供我们使用。

在这里要记住的是,运行的脚本名称在 sys.argv 的列表中总会位列第一。因此,在这一案例中我们将会有如下对应关系:’module_using_sys.py’ 对应 sys.argv[0],’we’ 对应 sys.argv[1],’are’ 对应 sys.argv[2],’arguments’ 对应 sys.argv[3]。要注意到 Python 从 0 开始计数,而不是 1。

sys.path 内包含了导入模块的字典名称列表。你能观察到 sys.path 的第一段字符串是空的——这一空字符串代表当前目录也是 sys.path 的一部分,它与 PYTHONPATH 环境变量等同。这意味着你可以直接导入位于当前目录的模块。否则,你必须将你的模块放置在 sys.path 内所列出的目录中。

另外要注意的是当前目录指的是程序启动的目录。你可以通过运行 import os; print(os.getcwd()) 来查看你的程序目前所处在的目录。