初学者的Python基础知识

对Python的介绍是针对Python语言的初级水平的学生。由于Python对初学者非常友好，但也可以利用它来应对地球上最激烈的编程挑战，因此它的受欢迎程度正在急剧上升。你可能还记得Python被用来拍摄黑洞照片的新闻。对我来说，这听起来像是一些重型的科学!在这方面，你可以从一个完全的初学者开始，并按你的意愿进展--这完全取决于你。在本教程中，我们将学习所有关于Python编程语言的基础知识，以及如何开始编写一些超级简单的程序。

---

编写Python代码

在本教程中，我们将在Windows上编写一些Python代码。为了开始，我们可以添加一个目录来存放我们所有的 Python 脚本。在我们的例子中，可以在/c/python/pythonforbeginners目录中找到，正如我们在这里看到的。

有很多工具可以用来编写Python代码，从简单的记事本程序到完整的集成开发环境，如JetBrains的PyCharm。我们将使用PyCharm，因为尽管我们只是初学者，但我们的愿望是很高的！我们将使用PyCharm。

你需要在你的机器上安装Python。用Python.org上提供的安装包之一来安装它非常容易。如果你还没有这样做的话，建议。当使用安装程序进行安装时，确保选择 "将Python添加到路径"!这将允许你从你机器上的任何目录位置简单地输入一个 Python shell。

好了，是时候写一个Python程序了。事实上，它将是hello world。首先要做的是打开我们的目录，该目录将容纳我们的Python代码作为PyCharm中的一个项目。

---

Python文件有一个 **.py**扩展

为了编写一些代码，我们需要一个文件来包含这些源代码。Python 文件有一个 **.py**扩展名，如果我们想写一个hello world程序，也许我们可以在我们的项目中添加一个 **helloworld.py**到我们的项目中。我们来了。

在该文件中，你可以添加以下代码。

print('hello world')

运行你的Python程序

我们尝试从我们的超级终端运行程序，我们得到一个问题。

pythonforbeginners $helloworld.py
bash: helloworld.py: command not found

相反，我们将改用Powershell作为我们的命令行程序，在那里运行该程序。要运行我们花哨的hello world程序，我们只需在命令行中输入python helloworld.py，就可以看到输出的所有内容了

我们还可以在PyCharm中直接运行该程序。实际上，有几种方法可以做到这一点，但其中一个简单的方法是，简单地右击你想运行的Python文件，然后像这样选择运行 "helloworld"。

如果一切按计划进行，一个集成的Python控制台将在PyCharm窗口的下部区域打开，并向你显示脚本的输出。在我们的例子中，那就是简单的'hello world'。

好吧！你可能会笑，但这可能是一个美丽旅程的开始，你将用Python编写精彩的程序来完成自动化任务、创建网站、从互联网上收集数据或任何其他你能想到的任务。你可能还对Django For Beginners感兴趣，因为它是用Python进行网络开发的。

---

Python中的变量和表达式

为了在Python程序中做任何有用的事情，你将需要使用变量。就像在其他编程语言中一样，Python中的变量是一个可以存储数值的内存位置。根据变量的类型，Python 解释器将分配内存并允许存储一个特定类型的变量。这些变量可以是整数、浮点数或字符串。

---

声明一个变量

有了这些知识，我们可以在PyCharm项目中添加一个 **variables.py**文件到我们的PyCharm项目，并测试一些变量的概念。

使用上面的代码，我们可以在Python REPL中进行尝试，它是任何Python安装中都会有的。在Powershell命令提示符下，我们可以输入 **python**来进入REPL。然后，我们简单地输入一个变量名称为 my_variable并使用赋值运算符(=)在该变量中放置一个数字值77。通过使用内置的*print()*函数，我们可以看到存储在of的输出。 my_variable.

PS C:pythonpythonforbeginners> python
Python 3.8.0 (tags/v3.8.0:fa919fd, Oct 14 2019, 19:21:23) [MSC v.1916 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> my_variable = 77
>>> print(my_variable)
77

---

重新声明/重写一个变量

在Python中，你可以简单地给命名的变量分配一个新的值，这将用新的值替换原来的值。新的值也可以是一个新的类型。这里我们用一个字符串覆盖了初始的整数。

>>> my_variable = "Put a string in the variable"
>>> print(my_variable)
Put a string in the variable

---

尊重数据类型

Python 是一种被称为强类型的语言。在创建一个变量时，你不需要声明类型，但是你需要尊重变量中包含的数据类型，因为Python没有类型强制（将一个值从一种类型转换为另一种类型的过程）。让我们来看看这个问题的实际情况。

添加两个相同类型的变量是完全可以的。

>>> print(7 + 7)
14

>>> print('string one ' + 'string two')
string one string two

这与试图将一个字符串添加到一个整数中形成鲜明对比。

>>> print('Seven' + 7)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

你不能这样做。你会得到一个像我们上面看到的类型错误。我们可以把数字 7 变成它的字符串表示，Python 解释器就不会再抱怨。

>>> print('Seven' + str(7))
Seven7

---

函数是如何影响变量的？

Python 中的函数对你在函数中声明的任何变量都有自己的本地拷贝。上面的例子一直在使用被称为全局变量的东西。这意味着它们可以从任何地方被访问。让我们看一个函数内部变量的例子，它不是全局的，而是局部的。我们可以定义一个函数，填充一个变量，然后把它打印出来。这整个逻辑都包含在函数本身中。

def my_function():
    local_variable = "Funk soul brother"
    print(local_variable)

现在我们可以通过简单地键入 my_function().我们应该看到字符串Funk soul brother输出到屏幕上。

如果我们试图访问 **local_variable**的时候，会发生什么？ print(local_variable)*在这个函数的*外面？嗯，我们会得到一个错误。

回溯（最近一次调用）：
File "C:/python/pythonforbeginners/variables.py", line 6, in
print(local_variable)
NameError: name 'local_variable' is not defined

考虑一下这段代码，它清楚地表明，函数外的 local_variable 和函数内的 local_variable 是两个不同的变量。

local_variable = "I'm actually global"


def my_function():
    local_variable = "Funk soul brother"
    print(local_variable)


my_function()
print(local_variable)

运行这个函数的输出结果是。

Funk soul brother
I'm actually global

Python的 **global**关键字

现在让我们像这样添加Python全局关键字。

local_variable = "I'm actually global"


def my_function():
    global local_variable
    local_variable = "Funk soul brother"
    print(local_variable)


print(local_variable)
my_function()
print(local_variable)

你认为上述代码的输出结果会是什么？

I'm actually global
Funk soul brother
Funk soul brother

在第一次调用 print(local_variable)的时候，出现了I'm actually global 的输出。然后我们运行函数 my_function()，出现了Funk soul brother的输出。现在在这一步中，由于我们使用了全局关键字，函数外的变量受到了影响。实际上，函数内部和外部的local_variable现在是同一个变量。在最后一次调用 **print(local_variable)**显示了这一点，Funk soul brother是输出的。

Python的 **del**关键字

del 关键字用于删除先前声明的变量的定义。这使得程序员可以通过使用del关键字实时撤销变量的定义。这个堆栈溢出线程对何时使用del关键字有一些想法。让我们在这里看一个将del用于工作的例子。

local_variable = "I'm actually global"


def my_function():
    global local_variable
    local_variable = "Funk soul brother"
    print(local_variable)
    del local_variable


print(local_variable)
my_function()
print(local_variable)

上述代码的输出是这样的。

I'm actually global
Funk soul brother

Traceback (most recent call last):
  File "C:/python/pythonforbeginners/variables.py", line 13, in 
    print(local_variable)
NameError: name 'local_variable' is not defined

第一次 print(local_variable) 工作正常，调用 my_function() 工作正常，但是最后一次调用 print(local_variable) 失败。它失败是因为在函数内部，我们添加了 **del local_variable**行。这就在它输出 local_variable 之后删除了那个 local_variable。

---

Python中的函数

无论用什么编程语言编写的应用程序，其逻辑都被分解成更小的、可重复使用的代码块，称为函数。这个概念在Python中也是如此。让我们来了解一下如何在Python中使用函数。

---

在Python中定义一个函数

要在 Python 中声明一个函数，你可以使用 **def**关键字。

def pyfunc():
    print("This is a function")


pyfunc()

This is a function

上面的函数不接受任何参数，但有一些有趣的事情需要考虑。如果你用 C、C#、PHP、Java 或 JavaScript 编程，你会注意到在 Python 中我们没有任何大括号。在Python中，大括号被冒号和缩进所取代，以表示函数。 **:**和缩进来表示函数范围。这就是在 Python 中定义函数的关键所在。你使用 **def**关键字、冒号和缩进。

---

函数的参数

一个函数的参数提供了在运行时向函数传递信息的能力。然后函数可以在完成它所设计的工作时使用这些信息。下面是一个简单的接收两个参数的GREATER函数。

def greeter(name, message):
    print('Hi ' + name + ', ' + message)


greeter('John', 'How are you today?')

Hi John, How are you today?

---

返回一个值

函数可以返回一个值。下面是一个函数，它接收一个数字，将其加倍，并返回它。

def doubler(number):
    return number * 2


doubler(128)

运行上述函数将不产生任何输出。为了利用返回值，你可以将返回值存储在一个变量中，然后像这样输出。

def doubler(number):
    return number * 2


result = doubler(128)
print(result)

256

---

默认参数值

为了演示默认参数值，我们可以看一下这个函数，它返回一个数字到一个特定的幂。现在，如果你不提供第二个参数，那么该函数将分配默认值2。因此，如果你调用power(2)，那么返回的是2的幂。另一方面，如果你调用power(2, 10)，那么返回2的10的幂。

def power(num, x=2):
    result = 1
    for i in range(x):
        result = result * num
    return result


result = power(2)
print(result)

4

def power(num, x=2):
    result = 1
    for i in range(x):
        result = result * num
    return result


result = power(2, 10)
print(result)

1024

---

可变的参数数

在Python中可以有的另一个东西是一个具有可变参数数的函数。使用这种方法，我们可以创建一个函数，将你提供给它的所有数字加起来。下面是这方面的代码。

def variableargs(*args):
    result = 0
    for x in args:
        result = result + x
    return result


print(variableargs(2, 2))

4

如果你用不同的参数数来调用这个函数，也没有问题

print(variableargs(2, 2, 5, 12, 77, 123, 875))

1096

---

使用if、else、elif和三元操作符的条件逻辑

程序需要做出决定才能发挥作用。一个程序经常需要比较数值，并根据一些逻辑结果来执行代码。这就是条件逻辑的用处。在 Python 中，条件式是由 if, else, **elif**和三元操作符来处理。

Python的if

Python if用来检查一个条件。如果条件为真，那么紧接着if条件测试的缩进代码将被执行。

下面是一个Python中if测试的简单例子。

foo = 50
bar = 100

if foo < bar:
    string = "foo is less than bar"

print(string)

在上面的例子中，foo变量持有50，而bar变量持有100。因此，当我们检查foo是否小于bar时，条件为真，所以foo小于bar被输出到终端。

Python的if else

if条件也可以有一个else子句。当if条件为假时，这很有用，但你希望发生一些其他行为。

这里我们在原来的 if 例子中添加了一个 else 子句。我们还把foo的值改为500，这样我们的else子句就会触发。

foo = 500
bar = 100

if foo < bar:
    string = "foo is less than bar"
else:
    string = "foo is greater than bar"

print(string)

foo is greater than bar

Python elif

Python中的elif与其他编程语言中的else if类似。

如果foo和bar变量相等呢？在这种情况下，我们需要为这个条件添加另一个检查，并正确处理它。为此，我们可以使用elif。

foo = 500
bar = 500

if foo < bar:
    string = "foo is less than bar"
elif foo == bar:
    string = "foo and bar are equal"
else:
    string = "foo is greater than bar"

print(string)

foo and bar are equal

Python的三元组

我们要看的最后一个流控制（条件）运算符是三元运算符。它就像if elif条件的简写。

foo = 500
bar = 1000

value = foo if foo < bar else bar

print(value)

500

说实话，Python中的三元运算符并不那么好读，所以最好还是坚持使用if、else和elif来进行流程控制。

---

用循环处理重复性的任务

编程的力量的一部分是能够非常迅速地重复简单的任务。就像其它编程语言一样，Python 提供了一些循环结构来处理这个问题。

While 循环

循环 **while**循环用于在一个特定条件为真时运行一个代码块。一些语言提供了各种做循环的方法。Python喜欢简化事情，提供了两种做循环的方式，即while和for。下面是一个关于Python while 循环的例子，我们将在一分钟内讨论for 循环。首先，我们来看看一个简单的while循环。

counter = 0

while (counter < 5):
    print(counter)
    counter = counter + 1

0
1
2
3
4

For 循环

for 循环经常与Python的range函数一起使用，就像这样。

for counter in range(3, 7):
    print(counter)

3
4
5
6

集合上的 For 循环

for 循环对事物的集合进行操作，而不仅仅是数字。在这个例子中，我们在一个颜色的列表上进行迭代。

colors = ["Red", "Green", "Blue", "Yellow", "Orange", "Purple", "White"]
for color in colors:
    print(color)

Red
Green
Blue
Yellow
Orange
Purple
White

断开和继续

break 语句用于在满足一个条件的情况下中断循环的执行。

断开

for counter in range(4, 11):
    if (counter == 8): break
    print(counter)

4
5
6
7

继续

与此相反的是continue语句，它基本上意味着跳过循环执行的其余部分。

for counter in range(4, 11):
    if (counter % 2 == 0): continue
    print(counter)

5
7
9

枚举的索引用法

为了获得一个列表项的索引，你可以使用python 的 enumerate 函数。它将像循环一样对一个集合进行迭代，但除了返回正在查看的项目的值之外，它还返回有关项目的索引值。

colors = ["Red", "Green", "Blue", "Yellow", "Orange", "Purple", "White"]
for index, color in enumerate(colors):
    print(index, color)

0 Red
1 Green
2 Blue
3 Yellow
4 Orange
5 Purple
6 White

---

面向对象的Python

Python有类，用来对数据和函数进行逻辑分组，这种方式易于重复使用，也易于建立。这就是Python变得真正有趣的地方。学习如何利用Python中的代码重用将使你建立各种有用的程序。

定义一个 Python 类

就像在所有的编程语言中一样，类就像一个蓝图，用来创建你可以在程序中使用的对象。理解这一点的最简单方法是像这样简单地创建一个Python类。

class Car:

    def __init__(self, make, model, color):
        self.make = make
        self.model = model
        self.color = color

上面的代码定义了一个汽车类。我们知道一辆车可以有一个颜色、一个品牌和一个型号。这就是为什么我们添加了这些变量来表示这些特征。你会注意到汽车定义中几个有趣的东西。首先是你可以看到__init__ 方法的定义。 **__init__**是 Python 类中的一个保留方法。它也被称为类的构造函数，用于初始化该类的任何变量。我们看到的另一个有趣的东西是 **self**关键字。self类似于 **this**在其他语言中。通常，一个类的任何方法的第一个参数是self参数，self参数指的是对象本身。

为类添加方法

类需要有方法，以便完成有趣和有用的任务。什么是方法？它们只是存在于类中的函数。所以让我们继续添加一个方法，输出关于我们汽车的所有信息。

class Car:

    def __init__(self, make, model, color):
        self.make = make
        self.model = model
        self.color = color

    def makemodel(self):
        return 'This is a {} {} {}'.format(self.color, self.make, self.model)

我们看到，new **makemodel()**方法通过self关键字接受了一个对象的实例。然后，我们可以使用self.color、self.make和self.model等东西来访问类的变量（属性）。在 **return**语句中，我们使用 format() 函数来简单地将变量数据插入返回的字符串中。这就像一种插值的形式。

从一个类中创建一个对象

我们有了蓝图，现在让我们创建一个类的实例。这很简单，使用这个简单的语法。

car1 = Car('Subaru', 'Outback', 'Blue')

我们现在可以使用print(car1)来查看这个新变量是什么。

<__main__.Car object at 0x00BD1DC0>

访问该实例的任何变量都可以这样做。

print(car1.make)
print(car1.model)
print(car1.color)

Subaru
Outback
Blue

另外，我们也可以只调用这一个方法来查看所有的信息。

print(car1.makemodel())

This is a Blue Subaru Outback

通过一个类，我们可以创建多个对象。让我们再创建一个汽车对象并进行测试。

car2 = Car('Tesla', 'Model 3', 'White')

print(car2.makemodel())

This is a White Tesla Model 3

---

Python日期和时间

处理日期和时间是一项常见的编程任务。Python 给你提供了几个模块来处理这些情况，如 date, time, datetime, calendar, , 和 timedelta.

日期和时间的基础知识

为了开始处理日期和时间，我们可以在一个新的python文件的顶部添加这两行。该 **datetime**模块提供了用于操作日期和时间的类。

from datetime import date
from datetime import datetime

为了得到今天的日期，我们可以使用日期类中简单的 today() 方法。

today = date.today()
print("Today's date is ", today)

Today's date is  2019-12-17

下面是如何打印出一个日期的各个组成部分。

print("Date Components: ", "Day:" + str(today.day), "Month:" + str(today.month), "Year:" + str(today.year))

Date Components:  Day:17 Month:12 Year:2019

每个工作日都有一个数字（0=周一，6=周日），你可以在你的程序中使用。

print("Today's Weekday number is: ", today.weekday())
days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
print("In other words, today is  " + days[today.weekday()])

Today's Weekday number is:  1
In other words, today is  Tuesday

从datetime类中获取今天的日期的例子。

today = datetime.now()
print("The current date and time is ", today)

The current date and time is  2019-12-17 13:28:46.764101

要获得当前时间，你可以使用.now()方法，像这样。

t = datetime.time(datetime.now())
print("The current time is ", t)

The current time is  13:29:46.171494

格式化日期和时间

上面的例子可以从一些更好的输出格式化中受益。Python 具有格式化日期和时间的能力，因此它们对用户更加友好。这里有几个例子。

带世纪的整年

now = datetime.now()
print(now.strftime("The current year is: %Y"))

The current year is: 2019

缩写的日，数字，全月，缩写的年

now = datetime.now()
print(now.strftime("%a, %d %B, %y")) 

Tue, 17 December, 19

当地的日期和时间

now = datetime.now()
print(now.strftime("Locale date and time: %c"))
print(now.strftime("Locale date: %x"))
print(now.strftime("Locale time: %X"))

Locale date and time: Tue Dec 17 13:36:56 2019
Locale date: 12/17/19
Locale time: 13:36:56

两种类型的时间格式

now = datetime.now()
print(now.strftime("Current time: %I:%M:%S %p"))  
print(now.strftime("24-hour time: %H:%M")) 

Current time: 01:36:56 PM
24-hour time: 13:36

---

使用日历数据工作

Python 有一个名为 calendar 的整洁模块，你可以用它做一些令人印象深刻的事情。

创建一个作为文本表的日历。酷!

c = calendar.TextCalendar(calendar.SUNDAY)
str = c.formatmonth(2020, 1, 0, 0)
print(str)

Su Mo Tu We Th Fr Sa
          1  2  3  4
 5  6  7  8  9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29 30 31

你可以用这段简单的代码创建一个相同日历的HTML版本。

htmlcalendar = calendar.HTMLCalendar(calendar.SUNDAY)
str = htmlcalendar.formatmonth(2020, 1)
print(str)

2020年1月
太阳	星期一	星期二	星期三	星期四	礼拜五	礼拜六
			1	2	3	4
5	6	7	8	9	10	11
12	13	14	15	16	17	18
19	20	21	22	23	24	25
26	27	28	29	30	31

日历模块为我们提供了一些对给定地区有用的实用工具，比如全称和缩写形式的日和月的名称。

for name in calendar.month_name:
    print(name)

January
February
March
April
May
June
July
August
September
October
November
December

for day in calendar.day_name:
    print(day)

Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday

使用日历模块，你可以算出某个特定会议的日期。例如，如果你知道某个会议在每个月的第一个星期二举行，你可以使用这个Python脚本来确定每个会议的日期。

print("The meetings fall on these dates:")
for m in range(1, 13):
    # returns an array of weeks that represent the month
    cal = calendar.monthcalendar(2020, m)
    # The first Tuesday has to be within the first two weeks
    weekone = cal[0]
    weektwo = cal[1]

    if weekone[calendar.TUESDAY] != 0:
        meetday = weekone[calendar.TUESDAY]
    else:
        # if the first tuesday isn't in the first week, it must be in the second
        meetday = weektwo[calendar.TUESDAY]

    print("%10s %2d" % (calendar.month_name[m], meetday))

The meetings fall on these dates:
   January  7
  February  4
     March  3
     April  7
       May  5
      June  2
      July  7
    August  4
 September  1
   October  6
  November  3
  December  1

Python中的Timedelta

timedelta()方法可以用来计算日期的差异，也可以用来在Python中进行日期操作。让我们看几个例子。

创建一个简单的timedelta并打印它

print(timedelta(days=365, hours=3, minutes=1))

365 days, 3:01:00

打印出今天的日期

now = datetime.now()
print("Today is: " + str(now))

Today is: 2019-12-17 14:12:26.606124

打印一年后的今天的日期

print("One year from now it will be: " + str(now + timedelta(days=365)))

One year from now it will be: 2020-12-16 14:12:26.606124

创建一个使用多个参数的timedelta

print("In a week and 3 days it will be: " + str(now + timedelta(weeks=1, days=3)))

In a week and 3 days it will be: 2019-12-27 14:12:26.606124

计算1周前的日期，格式化为字符串

t = datetime.now() - timedelta(weeks=1)
s = t.strftime("%A %B %d, %Y")
print("One week ago it was " + s)

One week ago it was Tuesday December 10, 2019

使用一个timedelta来计算离下一个圣诞节的天数。

today = date.today()
christmas = date(today.year, 12, 25)

if christmas < today:
    print("Christmas already went by %d days ago" % ((today - christmas).days))
    christmas = christmas.replace(year=today.year + 1)

time_to_christmas = christmas - today
print("It's just", time_to_christmas.days, "days until next Christmas!")

It's just 8 days until next Christmas!

---

在Python中处理文件

他们说，在Linux中，所有东西都是一个文件。这就是说，无论你在什么操作系统上工作，文件都是超级重要的。不管是Linux还是Windows，Python都能使文件系统的工作变得简单。让我们看看在 Python 中如何读写文件的一些例子。

要打开一个文件进行书写，你可以使用下面的代码。

file = open("mytextfile.txt", "w+")

现在你的文件已经打开了，你可以使用 .write() 方法向它写入。一旦完成，你要用 .close() 关闭文件。

for i in range(7):
    file.write("This is line %drn" % (i + 1))
file.close()

果然，如果我们在Python脚本运行的目录中查看，有一个新的mytextfile.txt文件。我们可以打开它，看看里面的内容。

我们可以用Python打开文件并读取其内容。为了说明这一点，让我们手动修改我们文件中的文本。我们只是在里面放一些随机的内容，然后我们将使用 Python 将内容读出到屏幕上。这里是更新后的文件。

现在我们将使用 .read() 方法一次性地读出文件的所有内容。

file = open("mytextfile.txt", "r")
if file.mode == 'r':  # check to make sure that the file was opened
    contents = file.read()
    print(contents)

我们可以在Pycharm中运行Python脚本，结果确实是我们在调试输出中所期望的。

我们还可以用这段代码逐行读取文件。

file = open("mytextfile.txt", "r")
if file.mode == 'r':
    filelines = file.readlines()
    for line in filelines:
        print(line)

该 **os**模块

在处理文件时，我们可以导入os模块来获得更多关于我们正在处理的操作系统和文件的信息。

要查看操作系统的名称，你可以使用这段代码。

print(os.name)

nt (windows)
posix (linux)

你可以使用.exists()、.isfile()和.isdir()方法来了解文件或目录的存在。

print("Item exists: " + str(path.exists("mytextfile.txt")))
print("Item is a file: " + str(path.isfile("mytextfile.txt")))
print("Item is a directory: " + str(path.isdir("mytextfile.txt")))

Item exists: True
Item is a file: True
Item is a directory: False

处理文件的路径可以用.realpath()来完成。

print("Item's path: " + str(path.realpath("mytextfile.txt")))
print("Item's path and name: " + str(path.split(path.realpath("mytextfile.txt"))))

Item's path: C:pythonpythonforbeginnersmytextfile.txt
Item's path and name: ('C:\python\pythonforbeginners', 'mytextfile.txt')

检查文件的修改时间，以及它在多长时间之前被修改过

t = time.ctime(path.getmtime("mytextfile.txt"))
print(t)

td = datetime.datetime.now() - datetime.datetime.fromtimestamp(path.getmtime("mytextfile.txt"))
print("It has been " + str(td) + " since the file was modified")

Tue Dec 17 14:52:35 2019
It has been 0:20:33.005550 since the file was modified

这里收集了一些你可以用os模块、目录和文件做的其他事情。

获取当前目录下文件的路径

src = path.realpath("mytextfile.txt")

通过在文件名后面加上 "bak "来制作一个备份副本

dst = src + ".bak"
# # now use the shell to make a copy of the file
shutil.copy(src, dst)

将权限、修改时间和其他信息复制到新文件中

shutil.copystat(src, dst)

重命名原始文件

os.rename("mytextfile.txt", "newfile.txt")

将目录内容放入ZIP档案

root_dir, tail = path.split(src)
shutil.make_archive("archive", "zip", root_dir)

---

网络刮削、JSON和XML

在这个Python入门教程中，我们要看的最后一个主题是：从互联网上获取数据，处理JSON格式的数据，以及解析XML结构的数据。Python 有各种内置的工具来完成这些任务，所以让我们看一下几个简单的例子。

向一个网络服务器发出请求

import urllib.request  # import urllib.request

# open a connection to a URL using urllib
webUrl = urllib.request.urlopen("https://www.bing.com")

# print out the http status code
print("result code: " + str(webUrl.getcode()))

# read the data from the URL and print it
data = webUrl.read()
print(data)

现在我们知道了如何从一个给定的URL中获取数据，我们将使用我们的技能来读取一个公共的JSON API。在这个例子中，我们将使用random.dog/woof.json。这… API在每次请求时都会返回一个随机的狗图片的URL。在浏览器中访问这个URL显示了结构化JSON响应的性质。

这里是我们的Python脚本，从这个公共API中获取JSON数据。

import urllib.request
import json

urlData = "https://random.dog/woof.json"

webUrl = urllib.request.urlopen(urlData)

print("result code: " + str(webUrl.getcode()))

if (webUrl.getcode() == 200):
    data = webUrl.read()
    theJSON = json.loads(data)
    print(theJSON['fileSizeBytes'])
    print(theJSON['url'])
else:
    print("Received an error from server, cannot retrieve results " + str(webUrl.getcode()))

在脚本的每次运行中，我们在Pycharm中看到这样的输出。

看看这个API为我们提供的所有可爱的狗狗吧

解析XML数据

考虑到我们有这个简单的XML文档，如图所示。

<?xml version="1.0" encoding="UTF-8" ?>
<car>
    <make>Tesla</make>
    <model>Model S</model>
    <color>Red</color>
    <option name="Autopilot"/>
    <option name="Extended Range"/>
    <option name="Clear Coat"/>
</car>

现在我们想用Python来读取这个XML文档并解析其结果。要做到这一点，我们可以使用像这样的脚本。

import xml.dom.minidom

# use the parse() function to load and parse an XML file
doc = xml.dom.minidom.parse("samplexml.xml")

# print out the document node and the name of the first child tag
print(doc.nodeName)
print(doc.firstChild.tagName)

# get a list of XML tags from the document and print each one
options = doc.getElementsByTagName("option")
print("%d options:" % options.length)
for option in options:
    print(option.getAttribute("name"))

#document
car
3 options:
Autopilot
Extended Range
Clear Coat

酷！"。我们还可以使用 Python 来修改，或者向 XML 结构中添加元素。这里的代码在当前的 XML 文档中添加了一个新的选项标签。

import xml.dom.minidom

# use the parse() function to load and parse an XML file
doc = xml.dom.minidom.parse("samplexml.xml")

# create a new XML tag and add it into the document
newOption = doc.createElement("option")
newOption.setAttribute("name", "Race Tires")
doc.firstChild.appendChild(newOption)

# read the new XML document
options = doc.getElementsByTagName("option")
print("%d options:" % options.length)
for option in options:
    print(option.getAttribute("name"))

4 options:
Autopilot
Extended Range
Clear Coat
Race Tires

---

了解更多关于初学Python的信息

这是对Python编程语言的一个很好的介绍，但你将需要更多的资源来尽可能多地学习!看看下面列出的一些不错的资源。

• 7天学会Python编程(Guru 99)
• 是什么使Python如此强大？(Edureka)
• 学习Python的最佳方法(After nerd)
• 初学者的Python项目(Dataquest)
• 100个简单步骤学习Python(Packtpub)
• Python初学者指南(Python.org)
• 用Python 3学习编程(Pythonprogramming)
• Python初学者的基本练习(Pynative)
• Python入门(Python.org)
• Python初学者教程(The Python Guru)
• Python初学者教程(软件测试帮助)
• 学习Python编程(Programiz)
• 1个月内学会并掌握Python 完整的Python指南(编程英雄)

---

初学者的Python基础知识总结

如果你能一路走过本教程，那么恭喜你！我们在这里涵盖了很多内容。我们在这里涵盖了很多内容，特别是如果你是Python的新手。我们涵盖了很多内容，包括Pycharm IDE、创建我们的第一个hello world脚本、变量和表达式、基本的Python函数、条件语句和循环、类、日期、时间、格式化时间、日历、处理文件、从网上获取数据、解析JSON数据以及操作XML数据。这个初学者级别的教程已经为深入挖掘Python做好了准备。