使用计算机时，经常需要列出一个文件夹或者目录的内容，创建和删除文件等操作，在 Python 程序中可以做到同样的事， 甚至能做更多的事。Python 在模块 os(操作系统，operating system)中提供了许多系统函数。本节的所有操作，都要导入这个模块。

1.文件

和其他语言一样，Python 的文件操作很像 Unix。有些函数的名字相同，比如 chown() 和 chmod()，不过也有很多新函数。

用open()创建文件

之前我们使用open()函数来打开文件或者创建文件。下面创建一个oops.txt的文本文件：

In [1]: import os

In [2]: fout = open('oops.txt','wt')

In [3]: print('Oops,I created a file.', file=fout)

In [4]: fout.close()

我们用这个文件进行一些测试

用exists()检查文件是否存在

要判断文件或者目录是否存在，可以使用 exists()，传入相对或者绝对路径名，如下所示：

In [5]: os.path.exists('oops.txt')

Out[5]: True

[6]: os.path.exists('./oops.txt')

Out[6]: True

In [7]: os.path.exists('sjkldfk')

Out[7]: False

In [8]: os.path.exists('.')

Out[8]: True

In [9]: os.path.exists('..')

Out[9]: True

用isfile()检查是否为文件

使用isfile判断是否为文件

In [10]: name = 'oops.txt'

In [11]: os.path.isfile(name)

Out[11]: True

使用isdir判断是否为目录：

In [12]: os.path.isdir(name)

Out[12]: False

一个点号(.)表示当前目录，两个点号(..)表示上层目录。它们一直存在，所以下面 的语句总会返回 True：

In [13]: os.path.isdir('.')

Out[13]: True

In [14]: os.path.isdir('..')

Out[14]: True

os 模块中有许多处理路径名(完整的文件名，由 / 开始并包含所有上级目录)的函数。其 中之一是 isabs()，可以判断参数是否是一个绝对路径名。参数不需要是一个真正的文件。

In [15]: os.path.isabs(name)

Out[15]: False

In [16]: os.path.isabs('/home/root/oops.txt')

Out[16]: True

In [17]: os.path.isabs('home/root/oops.txt')

Out[17]: False

用copy()复制文件

copy() 函数来自于另一个模块 shutil。下面的例子会把文件 oops.txt 复制到文件 ohno.txt：

In [18]: import shutil

In [19]: shutil.copy('oops.txt','ohno.txt')

Out[19]: 'ohno.txt'

shutil.move()函数会复制一个文件并删除原始文件。

用rename()重命名文件

下面的例子会把 ohno.txt 文件重命名为 ohwell.txt 文件：

In [20]: os.rename('ohno.txt','ohwell.txt')

用link()或者symlink()创建链接

在 Unix 中，文件只存在于一个位置，但是可以有多个名称，这种机制叫作链接。在更底 层的硬链接中，找到一个文件的所有名称并不容易。可以考虑使用符号链接，它会把新名 称当作文件存储，这样一次就可以获取到原始名称和新名称。link() 会创建一个硬链接。 symlink() 会创建一个符号链接。islink() 函数会检查参数是文件还是符号链接。

下面这个例子展示了如何把已有文件 oops.txt 硬链接到一个新文件 yikes.txt：

In [21]: os.link('oops.txt','yikes.txt')

In [22]: os.path.isfile('yikes.txt')

Out[22]: True

下面的例子展示了如何把已有文件 oops.txt 符号链接到一个新文件 jeepers.txt：

In [23]: os.path.islink('yikes.txt')

Out[23]: False

In [24]: os.symlink('oops.txt','jeepers.txt')

In [25]: os.path.islink('jeepers.txt')

Out[25]: True

用chmod()修改权限

在 Unix 系统中，chmod() 可以修改文件权限。可以设置用户(如果是你创建了文件，那用 户通常就是你)、当前用户所在用户组以及其他所有用户组的读、写和执行权限。这个命 令接收一个压缩过的八进制(基数为 8)值，这个值包含用户、用户组和权限。举例来说， 下面的命令可以让 oops.txt 只能被拥有者读：

In [26]: os.chmod('oops.txt',0o400)

如果不想用压缩过的八进制值并且更喜欢符号，可以从 stat 模块中 导入一些常量并用在语句中：

In [27]: import stat

In [28]: os.chmod('oops.txt',stat.S_IRUSR)

用chown()修改所有者

这个函数也是 Unix/Linux/Mac 特有的。我们可以指定用户的 ID(uid)和用户组 ID(gid)来 修改文件的所有者或所有用户组：

In [29]: uid = 1004

In [30]: gid = 1004

In [31]: os.chown('oops.txt',uid,gid)

用abspath()获取路径名

这个函数会把一个相对路径名扩展成绝对路径名。如果我们的当前目录是 /root/oops.txt， 其中有文件 oops.txt，那你可以用这个函数得到下面的输出：

In [32]: os.path.abspath('oops.txt')

Out[32]: '/root/oops.txt'

用realpath()获取符号的路径名

In [33]: os.path.realpath('jeepers.txt')

Out[33]: '/root/oops.txt'

用remove()删除文件

下面的栗子使用 remove() 函数来删除 oops.txt 文件：

In [34]: os.remove('oops.txt')

In [35]: os.path.exists('oops.txt')

Out[35]: False

2.目录

在大多数操作系统中，文件被存储在多级目录(现在经常被称为文件夹)中。包含所有这 些文件和目录的容器是文件系统(有时候被称为卷)。标准模块 os 可以处理这些东西，下 面是一些可以使用的函数。

使用mkdir()创建目录

如何创建目录

In [1]: import os

In [2]: os.mkdir('poems')

In [3]: os.path.exists('poems')

Out[3]: True

使用rmdir()删除目录

In [4]: os.rmdir('poems')

In [5]: os.path.exists('poems')

Out[5]: False

使用listdir()列出目录内容

In [6]: os.mkdir('poems')

列出内容：

In [7]: os.listdir('poems')

Out[7]: []

创建一个子目录

In [8]: os.mkdir('poems/mimin')

In [9]: os.listdir('poems')

Out[9]: ['mimin']

在子目录中创建一个文件

In [10]: fout = open('poems/mimin/the_good_man','wt')

In [11]: fout.write('''Cheerful and happy was his mood,

...: He to the poor was kind and good,

...: And he oft' times did find them food,

...: Also supplies of coal and wood,

...: He never spake a word was rude,

...: And cheer'd those did o'er sorrows brood,

...: He passed away not understood,

...: Because no poet in his lays

...: Had penned a sonnet in his praise,

...: 'Tis sad, but such is world's ways.

...: ''')

Out[11]: 349

In [12]: os.listdir('poems/mimin')

Out[12]: ['the_good_man']

使用glob()列出匹配文件

glob()函数会使用Unix shell的规则来匹配文件或目录，而不是正则表达式。

In [13]: import glob

匹配的是当前目录

试着获取所有以 m 开头的文件和目录：

In [14]: glob.glob('m*')

Out[14]:

['mp_test.py',

'master.zip',

'mongodb-linux-x86_64-rhel70-3.2.11.tgz',

'mp_pool.py',

'mp.py']

获取所有名称为两个字符的文件和目录：

In [15]: glob.glob('??')

Out[15]: ['lm', '-c']

获取名称为 10 个字符并且以 m 开头和以 p结尾的文件和目录：

In [16]: glob.glob('m????????p')

Out[16]: ['master.zip']

获取所有以 k、l 或者 m 开头并且以 y结尾的文件和目录：

In [17]: glob.glob('[lkm]*y')

Out[17]: ['mp_test.py', 'mp_pool.py', 'mp.py']

3.程序和进程

当运行一个程序的时候，操作系统机会创建一个进程，它会使用系统资源(CPU，内存和磁盘空间)和操作系统内核中的数据结构(文件，网络连接，用量统计等)。进程之间是互相隔 离的，即一个进程既无法访问其他进程的内容，也无法操作其他进程。

操作系统会跟踪所有正在运行的进程，给每个进程一小段运行时间，然后切换到其他进 程，这样既可以做到公平又可以响应用户操作。

我们可以自己编写程序来获取进程信息。标准库模块 os 提供了一些常用的获取系统信 息的函数。

举例来说，下面的函数会获取正在运行的 Python 解释器的进程号和当前工 作目录：

In [1]: import os

In [2]: os.getpid()

Out[2]: 26164

In [3]: os.getcwd()

Out[3]: '/root'

下面的函数会获取当前用户ID和用户组ID：

In [4]: os.getuid()

Out[4]: 621

In [5]: os.getgid()

Out[5]: 29

使用subprocess创建进程

我们可以使用Python标准库中的subprocess模块来启动和终止其他程序。如果我们只是想在shell中运行其他程序并获取它的输出(标准输出和标准错误输出)，可以使用getoutput()函数。

这里获得了Unix date程序的输出：

In [6]: import subprocess

In [7]: ret = subprocess.getoutput('date')

In [8]: ret

Out[8]: 'Thu Jan 19 10:36:44 CST 2017'

在程序执行完毕之前，我们获取不到任何内容。因为getoutput()的参数是一个字符串，可以表示一个完整的shell命令，所以我们可以在里面使用参数，管道，I/O重定向，等等：

In [9]: ret = subprocess.getoutput('date -u')

In [10]: ret

Out[10]: 'Thu Jan 19 02:39:07 UTC 2017'

把这个输出用管道传给 wc 命令，可以计算出一共有 1 行、6 个单词和 29 个字符：

In [11]: ret = subprocess.getoutput('date -u | wc')

In [12]: ret

Out[12]: ' 1 6 29'

另一个类似的方法是check_outout()，可以接受一个命令和参数列表。默认情况下，它返回的不是字符串，而是字节类型的标准输出。此外，这个函数并没有使用shell：

In [13]: ret = subprocess.check_output(['date','-u'])

In [14]: ret

Out[14]: b'Thu Jan 19 02:41:51 UTC 2017\n'

如果要获取其他程序的退出状态，可以使用getstatusoutput()函数，它会返回一个包含状态码和输出的元组：

In [15]: ret = subprocess.getstatusoutput('date')

In [16]: ret

Out[16]: (0, 'Thu Jan 19 10:42:36 CST 2017')

如果只是想要使用退出状态，可以使用call()：

In [17]: ret = subprocess.call('date')

Thu Jan 19 10:42:55 CST 2017

In [18]: ret

Out[18]: 0

在Unix类操作系统中，退出状态0通常表示运行成功

上面的日期和时间被打印到输出中，但并没有被我们的程序获取，所以ret中只有状态码。

可以用两种方式来运行带参数的程序。第一种是在字符串中写明参数。我们的示例中使用的是 date -u，这会打印出 UTC 格式的当前日期和时间：

In [19]: ret = subprocess.call('date -u',shell=True)

Thu Jan 19 02:46:33 UTC 2017

In [20]: ret

Out[20]: 0

需要加上参数shell=True，这样函数就会用shell来执行命令，shell会把date -u分割成单独的字符串并对通配符(比如 *，我们的例子中没有使用它)进行扩展。

第二种方式是传入一个参数列表，这样函数就不需要调用 shell：

In [21]: ret = subprocess.call(['date','-u'])

Thu Jan 19 02:47:24 UTC 2017

In [22]: ret

Out[22]: 0

使用multiprocessing创建进程

你可以在一个单独的进程中运行一个 Python 函数，也可以使用 multiprocessing 模块在 一个程序中运行多个进程。下面我们看一个小程序：

import multiprocessing

import os

def do_this(what):

whoami(what)

def whoami(what):

print("process %s says: %s" % (os.getpid(),what))

if __name__ == "__main__":

whoami("I'm the main program")

for n in range(4):

p = multiprocessing.Process(target=do_this,args=("I'm function %s" % n,))

p.start()

运行结果：

python pm.py

process 27943 says: I'm the main program

process 27944 says: I'm function 0

process 27945 says: I'm function 1

process 27946 says: I'm function 2

process 27947 says: I'm function 3

Process()函数会创建一个新的进程来运行do_this()函数。由于我们在一个循环中执行它，所以生成了4个执行do_this()的进程并在执行完毕后退出。

multiprocessing 模块真正的功能比这个例子中所展示的要强大得多。当需要用多进程来 减少运行时间时，它非常有用，比如下载需要抓取的网页、调整图片尺寸等。它支持任务 队列和进程间通信，而且可以等待所有进程执行完毕。

使用terminate()终止进程

如果创建了一个或者多个进程并且想终止它们，可以使用 terminate()。下面的例子 中，我们的进程会一直计数到一万，每次计数之后都会等待 1 秒并打印出相关信息。然 而，主程序只会保持 5 秒耐心，之后就会终止进程：

import multiprocessing

import time

import os

def whoami(name):

print("I'm %s, in process %s" % (name, os.getpid()))

def loopy(name):

whoami(name)

start = 1

stop = 1000000

for num in range(start, stop):

print("\tNumber %s of %s. Honk!" % (num, stop))

time.sleep(1)

if __name__ == "__main__":

whoami("main")

p = multiprocessing.Process(target=loopy, args=("loopy",))

p.start()

time.sleep(5)

p.terminate()

时间和日期

可以用多种方式来表示日期，甚至多到让人厌烦。

表示日期的方法：

• July 29 1984

• 29 Jul 1984

• 29/7/1984

• 7/29/1984

表示日期的第一个问题就是二义性。从上面的例子可以很容易看出，7 表示月份，29 表示 天数，因为月份不可能是 29。但是 1/6/2012 呢？它到底是 1 月 6 日还是 6 月 1 日呢？

下面 的代码可以检测是否是闰年：

In [1]: import calendar

In [2]: calendar.isleap(1900)

Out[2]: False

In [3]: calendar.isleap(1996)

Out[3]: True

In [4]:

In [4]: calendar.isleap(1999)

Out[4]: False

In [5]: calendar.isleap(2000)

Out[5]: True

In [6]: calendar.isleap(2002)

Out[6]: False

In [7]: calendar.isleap(2004)

Out[7]: True

Python 的标准库中有很多日期和时间模块：datetime、time、calendar、dateutil，等等。

datetime模块

datetime模块定义了4个主要的对象，每个对象都有很多方法：

date处理年月日

time处理时分秒和分数

datetime处理时期和时间同时出现的情况

timedelta 处理日期和时间间隔

我们可以指定年月日来创建一个对象，这些值之后会变成对象的属性：

In [12]: from datetime import date

In [13]: hallw = date(2017,1,22)

In [14]: hallw

Out[14]: datetime.date(2017, 1, 22)

In [15]: hallw

Out[15]: datetime.date(2017, 1, 22)

In [16]: hallw.day

Out[16]: 22

In [17]: hallw.month

Out[17]: 1

In [18]: hallw.year

Out[18]: 2017

可以使用isoformat()方法打印一个date对象：

iso 是指 ISO 8601，一种表示日期和时间的国际标准。这个标准的显示顺序是从一般(年) 到特殊(日)。它也可以对日期进行正确的排序：先按照年，然后是月，最后是日。

In [19]: hallw.isoformat()

Out[19]: '2017-01-22'

可以使用today()方法生成今天的日期：

In [20]: now = date.today()

In [21]: now

Out[21]: datetime.date(2017, 1, 22)

可以使用timedelta对象来实现date的加法：

In [22]: from datetime import timedelta

In [23]: ond_days = timedelta(days=1)

In [24]: tomorrow = now +ond_days

In [25]: tomorrow

Out[25]: datetime.date(2017, 1, 23)

In [26]: now + 17*ond_days

Out[26]: datetime.date(2017, 2, 8)

In [27]: yesterday = now - ond_days

In [28]: yesterday

Out[28]: datetime.date(2017, 1, 21)

date 的 范 围 是 date.min( 年 = 1， 月 = 1， 日 = 1) 到 date.max( 年 = 9999， 月 = 12， 日 = 31)。因此，不能使用它来进行和历史或者天文相关的计算。

datetime模块中的time对象用来表示一天中的时间：

In [29]: from datetime import time

In [30]: noon = time(9,25,28)

In [31]: noon

Out[31]: datetime.time(9, 25, 28)

In [32]: noon.hour

Out[32]: 9

In [33]: noon.minute

Out[33]: 25

In [34]: noon.second

Out[34]: 28

In [35]: noon.microsecond

Out[35]: 0

参数的顺序是按照时间单位从大(时)到小(微秒)排列。如果没有参数，time 会默认全 部使用 0。顺便说一句，能够存取微秒并不意味着你能从计算机中得到准确的微秒。每秒 的准确度取决于硬件和操作系统中的很多因素。

datetime 对象既包含日期也包含时间。我们可以直接创建一个 datetime 对象：

In [36]: from datetime import datetime

In [37]: some_day = datetime(2017,1,22,9,27,37,25)

In [38]: some_day

Out[38]: datetime.datetime(2017, 1, 22, 9, 27, 37, 25)

datetime对象也有一个isoformat()方法：

In [39]: some_day.isocalendar()

Out[39]: (2017, 3, 7)

In [40]: some_day.isoformat()

Out[40]: '2017-01-22T09:27:37.000025'

中间的T把日期和时间分割开。

datetime有一个now()方法，可以用它获取当前日期和时间：

In [41]: now = datetime.now()

In [42]: now

Out[42]: datetime.datetime(2017, 1, 22, 9, 30, 47, 837244)

In [43]: now.month()

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

in ()

----> 1 now.month()

TypeError: 'int' object is not callable

In [44]: now.month

Out[44]: 1

In [45]: now.day

Out[45]: 22

In [46]: now.hour

Out[46]: 9

In [47]: now.minute

Out[47]: 30

In [48]: now.second

Out[48]: 47

In [49]: now.microsecond

Out[49]: 837244

可以使用combin()方法把一个date对象和一个time对象合并成一个datetime()对象：

In [50]: from datetime import datetime,time,date

In [51]: noon = time(9,33)

In [52]: this_day = date.today()

In [53]: noon_today =datetime.combine(this_day,noon)

In [54]: noon_today

Out[54]: datetime.datetime(2017, 1, 22, 9, 33)

可以使用date()和time()方法从datetime中取出date和time部分：

In [55]: noon_today.date()

Out[55]: datetime.date(2017, 1, 22)

In [56]: noon_today.time()

Out[56]: datetime.time(9, 33)

使用time模块

一种表示绝对时间的方法是计算某个从开始点开始的秒数。Unix时间使用的是从1970年1月1日0点开始的秒数。这个值通常被称为纪元，它是不同系统之间最简单的交换日期 时间的方法。

time模块的time()函数会返回当前时间的纪元值：

In [57]: import time

time模块的time()函数会返回当前时间的纪元值：

In [58]: now = time.time()

In [59]: now

Out[59]: 1485051693.6350434

可以使用ctime()把一个纪元值转换成一个字符串：

In [60]: time.ctime(now)

Out[60]: 'Sun Jan 22 10:21:33 2017'

纪元值是不同系统(比如javascript)之间交换日期和时间的一种非常有用的方法。

但是， 有时候想要真正的日期而不是一串数字，这时可以使用 struct_time 对象。localtime() 会 返回当前系统时区下的时间，gmtime() 会返回 UTC 时间：

In [61]: time.localtime(now)

Out[61]: time.struct_time(tm_year=2017, tm_mon=1, tm_mday=22, tm_hour=10, tm_min=21, tm_sec=33, tm_wday=6, tm_yday=22, tm_isdst=0)

In [62]: time.gmtime(now)

Out[62]: time.struct_time(tm_year=2017, tm_mon=1, tm_mday=22, tm_hour=2, tm_min=21, tm_sec=33, tm_wday=6, tm_yday=22, tm_isdst=0)

In [63]: tm = time.localtime(now)

如果省略 localtime() 或者 gmtime() 的参数，默认会返回当前时间。

对应上面两个函数的是mktime()，它会把struct_time对象转换回纪元值。

In [64]: time.mktime(tm)

Out[64]: 1485051693.0

这个值和之前的now返回的纪元值不完全相同，因为struct_time对象只能精确到秒。

建议：尽量多使用 UTC 来代替时区。UTC 是绝对时间，和时区无关。如果你有服务 器，把它的时间设置为 UTC，不要使用本地时间。：如果有可能，绝对不使用夏时制时间。如果使用了夏时制 时间，那每年的一段时间(春季)会少一个小时，另一段时间(秋季)会多一个小时。出 于某些原因，许多组织在它们的计算机系统中使用夏时制，但是每年都需要处理数据重复 和丢失。

读写日期和时间

isoformat()并不是唯一一个可以打印日期和时间的方法。前面已经见过，time 模块中的 ctime() 函数可以把纪元转换成字符串：

也可以使用strftime()把时间和日期转换成字符串。这个方法在datetime，date和time对象中都有，在time模块中也有。strftime()使用格式化字符串来指定输出。

strftime()的格式化字符串:

格式化字符串 日期/时间单元 范围

%Y 年 1900-......

%m 月 01-12

%B 月名 January，......

%b 月名缩写 Jan,......

%d 日 01-31

%A 星期 Sunday，......

%a 星期缩写 Sun，......

%H 时(24小时制) 00-23

%I 时(12小时制) 01-12

%p 上午/下午 AM,PM

%M 分 00-59

%s 秒 00-59

数字都是左边补零

下面时time模块中的strftime()函数。它会把struct_time对象转换成字符串。我们先定义格式化字符串fmt，然后使用它：

In [1]: import time

In [2]: fmt = "It's %A,%B %d,%Y,local time %I:%M:%s%p"

In [3]: t =time.localtime()

In [4]: t

Out[4]: time.struct_time(tm_year=2017, tm_mon=1, tm_mday=22, tm_hour=14, tm_min=47, tm_sec=19, tm_wday=6, tm_yday=22, tm_isdst=0)

In [5]: time.strftime(fmt,t)

Out[5]: "It's Sunday,January 22,2017,local time 02:47:1485067639PM"

注意上面我们使用的是time模块。

如果使用date对象的strftime()函数，只能获取部分日期，时间默认是午夜：

In [6]: from datetime import date

In [7]: some_day = date(2017,1,22)

In [8]: fmt = "It's %A,%B %d,%Y,local time %I:%M:%s%p"

In [9]: some_day.strftime(fmt)

Out[9]: "It's Sunday,January 22,2017,local time 12:00:1485014400AM"

对于time对象，只会转换时间部分:

In [15]: from datetime import time

In [16]: some_time = time(14,56)

In [17]: fmt = "It's %A,%B %d,%Y,local time %I:%M:%s%p"

In [18]: some_time.strftime(fmt)

Out[18]: "It's Monday,January 01,1900,local time 02:56:-2208964183PM"

如果把字符串转换成日期或者时间，可以对同样的格式化字符串使用strftime()函数。

这里不能使用正则表达式，字符串的非格式化部分(没有%的部分)必须完全匹配。

假设 可以匹配格式“年 - 月 - 日”，比如 2012-01-29，如果目标字符串中用空格代替破折号， 解析时就会错误：

In [1]: import time

In [2]: fmt = "%Y-%m-%d"

In [3]: time.strptime("2017 01 22",fmt)

---------------------------------------------------------------------------

ValueError Traceback (most recent call last)

in ()

----> 1 time.strptime("2017 01 22",fmt)

/usr/local/lib/python3.5/_strptime.py in _strptime_time(data_string, format)

502 """Return a time struct based on the input string and the

503 format string."""

--> 504 tt = _strptime(data_string, format)[0]

505 return time.struct_time(tt[:time._STRUCT_TM_ITEMS])

506

/usr/local/lib/python3.5/_strptime.py in _strptime(data_string, format)

341 if not found:

342 raise ValueError("time data %r does not match format %r" %

--> 343 (data_string, format))

344 if len(data_string) != found.end():

345 raise ValueError("unconverted data remains: %s" %

ValueError: time data '2017 01 22' does not match format '%Y-%m-%d'

当我们传入strptime()的字符中有破折号就不会报错：

In [4]: time.strptime("2017-01-22",fmt)

Out[4]: time.struct_time(tm_year=2017, tm_mon=1, tm_mday=22, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=22, tm_isdst=-1)

即使字符串看起来可以匹配格式，但如果超出范围也会报错：

In [5]: time.strptime("2017-01-33",fmt)

---------------------------------------------------------------------------

ValueError Traceback (most recent call last)

in ()

----> 1 time.strptime("2017-01-33",fmt)

/usr/local/lib/python3.5/_strptime.py in _strptime_time(data_string, format)

502 """Return a time struct based on the input string and the

503 format string."""

--> 504 tt = _strptime(data_string, format)[0]

505 return time.struct_time(tt[:time._STRUCT_TM_ITEMS])

506

/usr/local/lib/python3.5/_strptime.py in _strptime(data_string, format)

344 if len(data_string) != found.end():

345 raise ValueError("unconverted data remains: %s" %

--> 346 data_string[found.end():])

347

348 year = None

ValueError: unconverted data remains: 3