阅读 11

Python脚本

Python 解释器

Python是一种解释性语言。

我们可以在Python交互式终端中访问Python的内置函数和库、安装模块和命令执行历史。你可以将准备好的代码拷贝到脚本中。

Python和Bash脚本的区别

  • Python是一种脚本语言,而Bash是一种用于进入和执行命令的shell
  • 使用Python更易于处理更大的程序
  • Python中大部分的事可通过导入模块来使用一行代码调用函数

变量

Python 中无需事先声明变量。Python 中可以想一个任意名称来作为变量名并进行赋值(译者注:仅能使用字母、数字和下划线且不能以数字开头)。可以在我们的程序中使用该变量。因此,Python 中我们可以在任何需使用的时候声明变量。

Python 中变量的值以及类型都可以在程序的执行过程中进行修改。以下代码中我们对变量赋值100:

>>> n = 100 # 这里我们对变量 n 赋值100,并在下面对n 的值加1
>>> n = n + 1
>>> print(n)
101
>>>
复制代码

以下为在执行过程中变量类型可进行改变的示例:

>>> a = 50 # 数据类型被隐式地设置为整型
>>> a = 50 + 9.50 # 数据类型被修改为浮点型
>>> a = "Seventy" # 现在变成了字符串类型
复制代码

变量的类型为它所引用的值的类型,查看以下代码:

>>> msg = 'And now for something completely different'
>>> a = 20
>>> pi = 3.1415926535897932
>>>
>>> type(msg)
<class 'str'>
>>> type(a)
<class 'int'>
>>> type(pi)
<class 'float'>
复制代码

数值

在Python中,除法(/) 运算符总是返回浮点值。向下取整运算符(//)获取的是整型结果。%运算符用于计算余数。

>>> 14/3
4.666666666666667
>>> 14//3
4
>>> 14%3
2
>>> 4*3+2
14
复制代码

计算幂值(指数运算),Python使用**运算符,如下例所示:

>>> 8**3
512
>>> 5**7
78125
复制代码

在Python交互终端中,_ 包含上一次打印过的表达式值,如下例所示:

>>> a = 18.5 / 100
>>> b = 150.50
>>> a * b
27.8425
>>> b + _
178.3425
>>> round(_, 2)
178.34
复制代码

数值数据类型存储数字,这是一种不可变的数据类型。如果进行改变,Python会为修改的数据类型分配一个新的对象。

我们可以通过赋值来创建数值对象,示例如下:

>>> num1 = 50
>>> num2 = 25
复制代码

del语句用于删除单个或多个变量。参考如下示例:

>>> num = num_a = num_b = 1
>>> del num
>>> del num_a, num_b
复制代码

在一些情况下,我们需要显式地将数字从一个类型转换为另一种类型来满足一些要求。Python在一个表达式中内部实现。

  • 输入int(a)来将a转换为整型
  • 输入float(a)来将a转换为浮点数
  • 输入complex(a)来将a转换复数,实部为a,虚部为0
  • 输入complex(a, b)来将a和 b转换为实部为a,虚部为b 的复数。a和 b为数字表达式

字符串

和数值类型,字符串也是Python中一种数据结构。Python可以操作字符串。字符串可通过如下方式表示:

  • 包含在单引号(‘…’)中
  • 包含在双引号(“…”)中
>>> 'Hello Python'
'Hello Python'
>>> "Hello Python"
'Hello Python'
复制代码

字符串是一组字符。我们可以像下面这样一次访问一个字符:

>>> city = 'delhi'
>>> letter = city[1]
>>> letter = city[-3]
复制代码

在第二个语句中,我们从city中选择数字为1的字符并将其赋值给letter。方括号中的数字为索引。索引表示要访问的字符,它从0开始。因此在前例中执行在赋值后输入 letter,将得到如下输出:

city	d  e  l  h  i 
索引	0  1  2  3  4
	-5 -4 -3 -2 -1

输出:
e
l
复制代码

字符串切片

字符串支持切片(slice)操作,这表示从字符串获取指定范围的字符。我们来看看下面的例子。注意起始的索引值是包含在内的,而结束值则排除在外。

假设字符串为str = “Programming”:

>>> str[0:2]
'Pr'
>>> str[2:5]
'ogr
复制代码

默认省略不写的第一个索引为0(省略第二个索引默认获取第一个索引到最后的所有字符),如下例所示:

>>> str = "Python"
>>> str[:2] + str[2:]
'Python'
>>> str[:4] + str[4:]
'Python'
>>> str[:2]
'Py'
>>> str[4:]
'on'
>>> str[-2:]
'on'
复制代码

我们可以通过方括号使用切片来访问字符串中的字符。我们还可以访问字符串中指定范围内的字符。参照如下示例:

#!/usr/bin/python3
str1 = 'Hello Python!'
str2 = "Object Oriented Programming"
print("str1[0]: ", str1[0])
print("str2[1:5]: ", str2[1:5])

输出:
str1[0]:  H
str2[1:5]:  bjec
复制代码

我们可以对一个指定索引重新赋新值来更新字符串。参照如下示例:

#!/usr/bin/python3
str1 = 'Hello Python!'
print("Updated String: - ", str1[:6] + 'John')

输出:
Updated String: -  Hello John
复制代码

Python 支持不可打印的转义字符(escape character),可通反斜线标记来进行展示。转义字符在单引号和双引号字符串中均可进行解释:

下表中显示了字符串的特殊运算符,假定a为Hello,b为World:

%是Python中的一个字符串格式化运算符。参照如下示例:

#!/usr/bin/python3
print("Hello this is %s and my age is %d !" % ('John', 25))

输出:
Hello this is John and my age is 25 !
复制代码

下表显示了配合%使用的符号列表:

字符串是不可变的,表示我们修改它的值。参照如下示例:

>>> welcome = 'Hello, John!'
>>> welcome[0] = 'Y'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
复制代码

因为字符串是不可变的(immutable),我们不能修改现有字符串。但我们可以创建一个与原来不同的新字符串:

>>> str1 = 'Hello John'
>>> new_str = 'Welcome' + str1[5:]
>>> print(str1)
Hello John
>>> print(new_str)
Welcome John
>>>
复制代码

列表

Python支持一种称为列表(list)的数据结构,它是一个可变和有序的元素序列。列表中的每个元素称为列表项。列表通过在方括号[ ]之间插入值定义。列中的每个元素都会给定一个数值,称们称之为位置或索引。索引从0开始,也即,第一个索引为0,第二个索引为1,以此类推。我们可对列表进行如下运算:索引、切片、相加、相乘以及检查是否为列表成员。

Python内置的length函数返回列表的长度。Python还有查找列表中最大项和最小项的函数。列表可以是数值列表、字符串列表或混合列表。

以下是创建列表的代码:

>>> l = list()
>>> numbers = [10, 20, 30, 40]
>>> animals = ['Dog', 'Tiger', 'Lion']
>>> list1 = ['John', 5.5, 500, [100, 450]]
复制代码

这里我们创建了三个列表:第一个是numbers,第二是animals,第三个是list1。列表中有另一个列表称为嵌套列表。list1是一个嵌套列表。不包含任何元素的列表称为空列表,可通过空的中括号[]来创建空列表。

>>> cities = ['Mumbai', 'Pune', 'Chennai']
>>> numbers_list = [75, 857]
>>> empty_list = []
>>> print(cities, numbers_list, empty_list)
['Mumbai', 'Pune', 'Chennai'] [75, 857] []
复制代码

我们可以使用索引值来访问列表中的值。我们将索引数字放在[ 和 ]之间。索引从0开始。参见如下示例:

#!/usr/bin/python3
cities = ['Mumbai', 'Bangalore', 'Chennai', 'Pune']
numbers = [1, 2, 3, 4, 5, 6, 7]
print(cities[0])
print(numbers[1:5])


输出结果:
Mumbai
[2, 3, 4, 5]
复制代码

可以更新列表中的元素,如以下代码所示:

#!/usr/bin/python3
cities = ['Mumbai', 'Bangalore', 'Chennai', 'Pune']
print('Original Value: ', cities[3])
cities[3] = 'Delhi'
print('New value: ', cities[3])


输出结果:
Original Value:  Pune
New value:  Delhi
复制代码

要删除列表中元素,如果知道要具体删除的元素可使用del语句。如果不知道具体要删除的列表项索引可使用remove()。参见如下示例:

#/usr/bin/python3
cities = ['Mumbai', 'Bangalore', 'Chennai', 'Pune']
print("Before deleting: ", cities)
del cities[2]
# cities.remove("Chennai") # 相同效果的补充
print("After deleting: ", cities)

输出结果:
Before deleting:  ['Mumbai', 'Bangalore', 'Chennai', 'Pune']
After deleting:  ['Mumbai', 'Bangalore', 'Pune']
复制代码

有五种基本列表运算:

  • 拼接
  • 重复
  • 取长度
  • 成员关系
  • 迭代

+运算符将列表进行拼接:

>>> a = [30, 50, 60]
>>> b = ['Hello', 75, 66]
>>> c = a + b
>>> print(c)
[30, 50, 60, 'Hello', 75, 66]
复制代码

相似地,*运算符以给定次数重复列表:

>>> [0] * 4
[0, 0, 0, 0]
>>> ['Python'] * 3
['Python', 'Python', 'Python']
复制代码

列表索引与字符串索引的运作方式相同。列表值可通过索引来访问。如果尝试将不存在的元素写入列表,会得到IndexError。如果索引为负值,会从列表的最后开始倒数。

现在我们创建一个名为cities的列表并查看列表的索引运算:

cities = ['Mumbai', 'Bangalore', 'Chennai', 'Pune']
复制代码

元组

Python 的元组(tuple)数据结构是不可变的,这表示不能修改元组中的元素。 基本上,元组是一个以逗号分隔的值的序列,以括号( )进行包裹。和列表类似,元组是一个有序的元素序列:

t1 = 'h', 'e', 'l', 'l', 'o'
复制代码

元组以括号( )进行包裹:

t1 = ('h', 'e', 'l', 'l', 'o')
复制代码

我们还可以创建一个只有一个元素的元组,仅需在元组的最后加一个逗号:

>>> t1 = 'h',
>>> type(t1)
<class 'tuple'>
复制代码

把值放到括号中并不是元组:

>>> t1 = ('a')
>>> type(t1)
<class 'str'>
复制代码

我们可以使用tuple()函数来创建空的元组:

>>> t1 = tuple()
>>> print(t1)
()
复制代码

如果该函数的参数是一个序列(字符串、列表或元组),结果是这个序列元素组成的元组:

>>> t = tuple('mumbai')
>>> print(t)
('m', 'u', 'm', 'b', 'a', 'i')
复制代码

元组的值在括号( ) 中以逗号分隔:

>>> t = ('a', 'b', 'c', 'd', 'e')
>>> print(t[0])
a
复制代码

切片运算符选取一个范围内的元素。

>>> print(t[1:3])
('b', 'c')
复制代码

要访问元组中的值,使用方括号切片与单个或多个索引结合来获取对应索引的值,如下例所示:

#!/usr/bin/python3
cities = ('Mumbai', 'Bangalore', 'Chennai', 'Pune')
numbers = (1, 2, 3, 4, 5, 6, 7)
print(cities[3])
print(numbers[1:6])

输出结果:
Pune
(2, 3, 4, 5, 6)
复制代码

我们不能删除单个数据元组。因此要显式地删除整个元组,使用del语句。参照如下示例:

#!/usr/bin/python3
cities = ('Mumbai', 'Bangalore', 'Chennai', 'Pune')
print("Before deleting: ", cities)
del cities
print("After deleting: ", cities)


输出结果:
Before deleting:  ('Mumbai', 'Bangalore', 'Chennai', 'Pune')
Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print("After deleting: ", cities)
NameError: name 'cities' is not defined
复制代码

和列表相似,有五种基本元组运算:

  • 拼接
  • 重复
  • 取长度
  • 成员关系
  • 迭代

元组索引的运作方式和列表相同。使用索引可访问元组的值。如果尝试读取或写入不存在的元素,会报出IndexError。如果索引为负值,则从元组的最后向前数。

现在我们创建一个名为cities的元组并查看列表的索引运算:

cities = ('Mumbai', 'Bangalore', 'Chennai', 'Pune')
复制代码

使用max()和min()函数,我们可以查找元组中的最大值和最小值。这两个函数让我们可以找到量化数据的相关信息。我们来看看下面这个例子:

>>> numbers = (50, 80, 98, 110.5, 75, 150.58)
>>> print(max(numbers))
150.58
复制代码

使用max()可以获取元组中的最大值。相似地,我们可以使用min()函数:

>>> numbers = (50, 80, 98, 110.5, 75, 150.58)
>>> print(min(numbers))
50
复制代码

集合

集合(set)是一个无序且无重复值的元素集。集合的基本用法是检查成员关系测试和删除重复项。这些集合对象支持数学运算,如并集、交集、差集以及对等差分。我们可以使用大括号{}或函数set()来创建集合。如果想要创建一个空的集合,使用set()而不是{}。

以下是一个简单的演示:

>>> fruits = {'Mango', 'Apple', 'Mango', 'Watermelon', 'Apple', 'Orange'}
>>> print(fruits)
{'Orange', 'Apple', 'Watermelon', 'Mango'}
>>> 'Orange' in fruits
True
>>> 'Onion' in fruits
False
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'c', 'r', 'b', 'a', 'd'}
>>> a - b
{'r', 'b', 'd'}
>>> a | b
{'c', 'l', 'd', 'b', 'z', 'r', 'm', 'a'}
>>> a & b
{'c', 'a'}
>>> a ^ b
{'l', 'd', 'b', 'z', 'r', 'm'}
复制代码

Python 中还支持集合推导式(set comprehension),参见如下代码:

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
复制代码

字典

字典(dictionary)是Python中的一种数据类型,它由键值对组成并包裹在大括号{}中。字典是无序的并通过键进行索引,且每个键必须是唯一的。这些键必须为不可变类型。元组在包含字符串、数字或元组时可作为字典的键。

仅仅使用一对大括号{}会创建一个空的字典。字典的主要运算是使用某些键来存储值并通过给定的键来提取值。同样可以使用 del 来删除一个键值对。如果使用了已有的键进行存储,就会抹除该键原来关联的值。使用不存在的键来提取值会报错。以下是使用字典的一个小例子:

>>> student = {'Name':'John', 'Age':25}
>>> student['Address'] = 'Mumbai'
>>> student
{'Name': 'John', 'Address': 'Mumbai', 'Age': 25}
>>> student['Age']
25
>>> del student['Address']
>>> student
{'Name': 'John', 'Age': 25}
>>> list(student.keys())
['Name', 'Age']
>>> sorted(student.keys())
['Age', 'Name']
>>> 'Name' in student
True
>>> 'Age' not in student
False
复制代码

自选的键值表达式配合字典推导式可用于创建字典:

>>> {x: x**2 for x in (4, 6, 8)}
{4: 16, 6: 36, 8: 64}
复制代码

在键是简单的字符串时,使用关键字参数的方式指定键值对更为容易:

>>> dict(John=25, Nick=27, Jack=28)
{'Nick': 27, 'Jack': 28, 'John': 25}
复制代码

解析命令行参数

我们可以在命令行中添加额外的参数来启动程序。Python的程序可通过命令行参数来启动。让我们来看看下面这个例子:

$ python program_name.py img.jpg
复制代码

这里program_name.py和img.jpg都是参数。我们将使用模块来获取这些参数:

Sys.argv

sys模块用于访问命令行参数。len(sys.argv) 函数包含参数的数量。要打印所有的参数,只需执行str(sys.argv)。让们来看看下面这个例子:

# 01.py
import sys
print('Number of arguments: ', len(sys.argv))
print('Argument list: ', str(sys.argv))

# 运行
python3 01.py img
# 执行结果
Number of arguments:  2
Argument list:  ['01.py', 'img']
复制代码

argparse

argparse 是 Python 内置的一个用于命令项选项与参数解析的模块,通过在程序中定义好我们需要的参数,argparse 将会从 sys.argv 中解析出这些参数,并自动生成帮助和使用信息。当然,Python 也有第三方的库可用于命令行解析,而且功能也更加强大,比如 docopt,Click。

我们先来看一个简单示例。主要有三个步骤:

  • 创建 ArgumentParser() 对象
  • 调用 add_argument() 方法添加参数
  • 使用 parse_args() 解析添加的参数
# -*- coding: utf-8 -*-

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('integer', type=int, help='display an integer')
args = parser.parse_args()

print args.integer
复制代码

将上面的代码保存为文件 argparse_usage.py,在终端运行,结果如下:

$ python argparse_usage.py
usage: argparse_usage.py [-h] integer
argparse_usage.py: error: too few arguments

$ python argparse_usage.py abcd
usage: argparse_usage.py [-h] integer
argparse_usage.py: error: argument integer: invalid int value: 'abcd'

$ python argparse_usage.py -h
usage: argparse_usage.py [-h] integer

positional arguments:
  integer     display an integer

optional arguments:
  -h, --help  show this help message and exit

$ python argparse_usage.py 10
10
复制代码

上面的示例,其实就展示了定位参数的使用,我们再来看一个例子 - 计算一个数的平方:

# -*- coding: utf-8 -*-

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("square", help="display a square of a given number", type=int)
args = parser.parse_args()
print args.square**2
复制代码

将上面的代码保存为文件 argparse_usage.py,在终端运行,结果如下:

$ python argparse_usage.py 9
81
复制代码

现在看下可选参数的用法,所谓可选参数,也就是命令行参数是可选的,废话少说,看下面例子:

# -*- coding: utf-8 -*-

import argparse

parser = argparse.ArgumentParser()

parser.add_argument("--square", help="display a square of a given number", type=int)
parser.add_argument("--cubic", help="display a cubic of a given number", type=int)

args = parser.parse_args()

if args.square:
    print args.square**2

if args.cubic:
    print args.cubic**3
复制代码

将上面的代码保存为文件 argparse_usage.py,在终端运行,结果如下:

$ python argparse_usage.py --h
usage: argparse_usage.py [-h] [--square SQUARE] [--cubic CUBIC]

optional arguments:
  -h, --help       show this help message and exit
  --square SQUARE  display a square of a given number
  --cubic CUBIC    display a cubic of a given number

$ python argparse_usage.py --square 8
64

$ python argparse_usage.py --cubic 8
512

$ python argparse_usage.py 8
usage: argparse_usage.py [-h] [--square SQUARE] [--cubic CUBIC]
argparse_usage.py: error: unrecognized arguments: 8

$ python argparse_usage.py  # 没有输出
复制代码

定位参数和选项参数可以混合使用,看下面一个例子,给一个整数序列,输出它们的和或最大值(默认):

import argparse

parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('integers', metavar='N', type=int, nargs='+',
                   help='an integer for the accumulator')
parser.add_argument('--sum', dest='accumulate', action='store_const',
                   const=sum, default=max,
                   help='sum the integers (default: find the max)')

args = parser.parse_args()
print args.accumulate(args.integers)
复制代码

结果:

$ python argparse_usage.py
usage: argparse_usage.py [-h] [--sum] N [N ...]
argparse_usage.py: error: too few arguments
$ python argparse_usage.py 1 2 3 4
4
$ python argparse_usage.py 1 2 3 4 --sum
10
复制代码

add_argument() 方法定义如何解析命令行参数:

ArgumentParser.add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])
复制代码

每个参数解释如下:

  • name or flags - 选项字符串的名字或者列表,例如 foo 或者 -f, --foo。

  • action - 命令行遇到参数时的动作,默认值是 store。

      store_const,表示赋值为const;
      append,将遇到的值存储成列表,也就是如果参数重复则会保存多个值;
      append_const,将参数规范中定义的一个值保存到一个列表;
      count,存储遇到的次数;此外,也可以继承 argparse.Action 自定义参数解析;
    复制代码
  • nargs - 应该读取的命令行参数个数,可以是具体的数字,或者是?号,当不指定值时对于 Positional argument 使用 default,对于 Optional argument 使用 const;或者是 * 号,表示 0 或多个参数;或者是 + 号表示 1 或多个参数。

  • const - action 和 nargs 所需要的常量值。

  • default - 不指定参数时的默认值。

  • type - 命令行参数应该被转换成的类型。

  • choices - 参数可允许的值的一个容器。

  • required - 可选参数是否可以省略 (仅针对可选参数)。

  • help - 参数的帮助信息,当指定为 argparse.SUPPRESS 时表示不显示该参数的帮助信息.

  • metavar - 在 usage 说明中的参数名称,对于必选参数默认就是参数名称,对于可选参数默认是全大写的参数名称.

  • dest - 解析后的参数名称,默认情况下,对于可选参数选取最长的名称,中划线转换为下划线.

决策制定

a = 10
if a > 50:
        print("a is greater than 50")
elif a == 10:
        print("a is equal to 10")
else:
        print("a is negative")

输出结果:
a is equal to 10
复制代码

循环

for循环遍历序列或其它可迭代对象中的每一项,并每次执行for代码块中的语句。参照如下代码:

for i in sequence:
        for loop body
复制代码

例子:

numbers = [6, 5, 3, 8, 4, 2, 5, 4, 11]
sum = 0
for i in numbers:
        sum = sum + i
        print("The sum is", sum)

输出结果:
The sum is 6
The sum is 11
The sum is 14
The sum is 22
The sum is 26
The sum is 28
The sum is 33
The sum is 37
The sum is 48
复制代码

Python的range()函数会生成一个数字的序列。例如,range(10)会生成0到9的数字(共10个数字)。

我们还可以定义起始、结束和步长来作为参数,这时range()函数如下所示:

range(start, stop, step size).

如未设置步长默认为1。
复制代码

使用range()函数的 for 循环示例如下:

for i in range(5):
        print("The number is", i)

输出结果:
The number is 0
The number is 1
The number is 2
The number is 3
The number is 4
复制代码

while是一个在测试表达式为true时不停遍历代码块的循环语句。我们在不知道要迭代多少次时使用这一循环。参见如下代码:

while test_expression:
        while body statements
复制代码

以下为while循环的示例:

a = 10
sum = 0
i = 1
while i <= a:
        sum = sum + i
        i = i + 1
        print("The sum is", sum)


运行结果:
The sum is 1
The sum is 3
The sum is 6
The sum is 10
The sum is 15
The sum is 21
The sum is 28
The sum is 36
The sum is 45
The sum is 55
复制代码

迭代器

Python中的迭代器是可进行迭代的对象。这个对象会返回数据,每次返回一个元素。Python的迭代器对象实现了两个方法:iter()和__next__()。大多数情况下迭代器在循环、生成器和推导式中实现。

下例中,我们使用了next()函数,它会遍历所有的元素。在到达最后且没有更多数据返回时,会抛出StopIteration,如下例所示:

numbers = [10, 20, 30, 40]

numbers_iter = iter(numbers)

print(next(numbers_iter))
print(next(numbers_iter))
print(numbers_iter.__next__())
print(numbers_iter.__next__())

next(numbers_iter)


输出结果:
10
20
30
40
Traceback (most recent call last):
  File "test.py", line 10, in <module>
    next(numbers_iter)
StopIteration
复制代码

生成器

我们可以使用Python生成器来创建迭代器。Python中生成器是返回一个可以迭代对象的函数。

在Python中创建生成器非常容易。我们可以定义一个函数,使用yield语句来代替return语句即可创建生成器。如果函数中至少包含一个yield语句,它就变成了一个生成器函数。yield和return语句会从函数中返回某些值。以下为示例:

def my_gen():
        n = 1
        print("This is printed first")
        yield n
        n += 1
        print("This is printed second")
        yield n
        n += 1
        print("This is printed at last")
        yield n

for item in my_gen():
        print(item)

输出结果:
This is printed first
1
This is printed second
2
This is printed at last
3
复制代码

函数

参见如下示例:

def welcome(name):
        print("Hello " + name + ", Welcome to Python Programming!")

welcome("John")

输出结果:
Hello John, Welcome to Python Programming!
复制代码

如果没有表达式,函数会返回None对象,如下例所示:

def return_value(a):
        if a >= 0:
                return a
        else:
                return -a

print(return_value(2))
print(return_value(-4))

输出结果:
2
4
复制代码

Python中匿名函数是未定义函数名的函数,称为lambda函数,使用关键字lambda进行定义。在需要短暂使用一个函数时我们使用这类函数。

lambda函数与内置的函数共同使用,如filter()和map()。

filter()函数返回一个元素列表,并仅接收一个迭代值。以下为使用filter()的示例:

numbers = [10, 25, 54, 86, 89, 11, 33, 22]
new_numbers = list(filter(lambda x: (x%2 == 0), numbers))

print(new_numbers)

输出结果:
[10, 54, 86, 22]
复制代码

在本例中,filter()接收一个lambda函数以及一个列表来作为参数。

map()函数在应用指定函数之后返回一个结果列表。下面我们来看看使用map()的示例:

my_list = [1, 5, 4, 6, 8, 11, 3, 12]
new_list = list(map(lambda x: x * 2, my_list))
print(new_list)

输出结果:
[2, 10, 8, 12, 16, 22, 6, 24]
复制代码

这里,map()函数接收一个lambda函数和一个列表。

模块

模块只是包含Python语句和定义的文件。一个包含Python代码的文件(如sample.py)称为一个模块,并且模块名应为sample。使用模块,我们可以将大型的程序分解成更小和有组织的程序。模块的一个重要特性是复用性。我们无需在不同程序中拷贝经常使用到的函数定义,而是将它们定义在一模块中,然后需要使用时进行导入。

我们来创建一个模块并导入。我们将创建两个脚本:sample.py和add.py。然后在add.py中导入sample模块。现在将如下代码保存到sample.py文件中。我们来看看下面这个示例:

# sample.py
def addition(num1, num2):
        result = num1 + num2
        return result
复制代码

这里我们在名为sample的模块中定义了一个函数addition()。该函数接收两个数值并返回和。这样我们就创建了一个模块。我们可以在任意Python程序中导入该模块。

在创建模块后,我们来学习如何导入这一模块。上例中我们创建了一个sample模块。现在我们就在add.py脚本中导入sample模块:

# add.py
import sample
sum = sample.addition(10, 20)
print(sum)

输出结果:
30
复制代码
关注下面的标签,发现更多相似文章
评论