1.4 Python语言基础要素
1.4.1 数值
1.4.1.1 整数
x = 9
print("Output #4: {0}".format(x))
print("Output #5: {0}".format(3**4)) #3的4次方# 浮点型转为整型会进行向下取整
print("Output #6: {0}".format(int(8.3)/int(2.7)))
方法int(x [ , base=10]) 将 x 强制转换为 int 或 long（长整型）
base：指定x的进制。默认x为十进制。当x不是十进制时，必须用base指明其进制，否则会报错。
x：通常为一个整形/浮点型数值，或为字符串Stringprint(int('0xa',16)) print(int('1010',2))
1.4.1.2 浮点数
print("Output #7: {0:.3f}".format(8.3/2.7))y = 2.5*4.8
print("Output #8: {0:0.1f}".format(y)) #精确到小数位后1位
print(type(y)) #查看y的数据类型r = 8/float(3)
print("Output #9: {0:.2f}".format(r)) #精确到小数位后2位
print(type(r)) #查看r的数据类型print("Output #10: {0:.4f}".format(8.0/3)) #精确到小数位后4位
#!/usr/bin/env python3
from math import exp,log,sqrt #math模块print("Output #11: {0:.4f}".format(exp(3))) #自然常数e的三次方
print("Output #12 {0:.2f}".format(log(4))) #返回4的自然对数【第二个参数为底数，可选，默认为 e】
print("Output #13: {0:.1f}".format(sqrt(81))) #返回81的平方根
Python中的其它幂运算
① 幂运算符（）可以用来计算任何幂次
② math库提供了另一个pow函数，可以用来计算幂次。
③Numpy中的cbrt函数专门用于计算立方根。
python中如何用开立方根
1.2 绝对误差、相对误差与有效数字 —— 夏驰和徐策
python中的1e-3、1e-4等微小量 —— 吃块小西瓜
1e-3：表示一个微小值，有3个0构成的0.001
7e-9：表示有9个0构成的0.000000007
10e-60：表示有60个0构成的0.000……0001
xe-y：表示有y个0构成的0.000……000x
from math import pow
from numpy import cbrtprint(pow(1000,1/3))
# 输出：9.999999999999998a = pow(1000,1/3)
print(round(a,10)) #四舍五入到小数点后10位
# 输出：10.0#用 1e-9 作为误差容限，进行判断与打印
result = pow(1000, 1/3)
if abs(result - round(result)) < 1e-9: # 判断result是否足够接近整数（绝对误差是否小于0.000000001）print(round(result))
else:print(result)
# 如果是，则打印result四舍五入到整数后的结果；如果不是，则打印原始结果。
# 输出：10print(cbrt(1000))
# 输出：10.0number = 27 ** (1/3)
print(number)
# 输出：3.0
1.4.2 字符串
print("Output 14#: {0:s}".format('I\'m enjoying learning Python.'))print("Output 15#: {0:s}".format("This is a long string. Without the backslash \it would run off of the page on the right in \the text editor and be very difficult to read\and edit. By using the backslash you can split \the long string into smaller strings on separate \lines so that the whole string is easy to view \in the text editor."))print("Output #16: {0:s}".format(''' You can use triple single quotes for multi-line comment strings. ''')) print("Output #17: {0:s}".format(""" You can also use triple double quotes for multi-line comment strings. """))
string1 = "This is a "
string2 = "short string."
sentence = string1 + string2 # + 操作符将两个字符串按照原样相加
print("Output #18: {0:s}".format(sentence))print("Output #19: {0:s} {1:s}{2:s}".format("She is","very "*4,"beautiful."))m = len(sentence)
print("Output #20: {0:d}".format(m))
1.4.2.1 split 和 join
string1 = "My deliverable is due in May"# split函数的返回值是一个字符串列表string1_list1 = string1.split() # 默认使用空格进行拆分，有几个空格就拆分几次
print("Output #21: {0}".format(string1_list1)) # 以列表的形式，打印列表string1_list1中的所有元素string1_list2 = string1.split(" ",2) # 使用空格进行拆分，拆分两次
print("Output #22: FIRST PIECE:{0} SECOND PIECE:{1} THIRD PIECE:{2}" .format(string1_list2[0],string1_list2[1],string1_list2[2]))
# 代码过长，可直接换行，继续书写string2 = "Your,deliverable,is,due,in,June"
string2_list = string2.split(',') # 使用,进行拆分，有几个,就拆分几次
print("Output #23: {0}".format(string2_list)) # 以列表的形式，打印列表string2_list中的所有元素
print("Output #24: {0} {1} {2}".format(string2_list[1],string2_list[5],string2_list[-1]))
print("Output #25: {0}".format(",".join(string2_list))) # join 函数使用 , 将列表string2_list中的元素（子字符串）组合成一个字符串
在Python中，索引也可以从尾部访问，最后一个元素的索引为-1，倒数第二个元素为-2，以此类推。
当有时候弄不清最后一个元素，或只想取最后几个元素时，可以用这个方法。
1.4.2.3 strip
string3 = " Remove unwanted characters from this string.\t\t \n"
print("Output #26: string3: {0:s}".format(string3))string3_lstrip = string3.lstrip() # 删除左侧的空格、制表符和换行符
print("Output #27: lstrip: {0:s}".format(string3_lstrip))string3_rstrip = string3.rstrip() # 删除右侧的空格、制表符和换行符
print("Output #28: rstrip: {0:s}".format(string3_rstrip))string3_strip = string3.strip() # 删除两侧的空格、制表符和换行符
print("Output #29: strip: {0:s}".format(string3_strip))# 用strip函数从字符串两端删除（除空格、制表符和换行符之外的）其他字符
string4 = "$$Here's another string that has unwanted characters.__---++"
print("Output #30: {0:s}".format(string4))string4 = "$$The unwanted characters have been removed.__---++"
string4_strip = string4.strip('$_-+') #直接将要删除的所有字符作为附加参数
print("Output #31: {0:s}".format(string4_strip))
1.4.2.4. replace
string5 = "Let's replace the spaces in this sentence with other characters."
string5_replace = string5.replace(" ","!@!") #replace函数第二个参数可以是一个字符，也可以是一组字符
print("Output #32: (with !@!): {0:s}".format(string5_replace))string5_replace = string5.replace(" ",",")
print("Output #33: (with commas):{0:s}".format(string5_replace))
1.4.2.5 lower、upper、capitalize
string6 = "Here's WHAT Happens WHEN You Use lower."
print("Output #34: {0:s}".format(string6.lower())) # 每一个单词的每一个字母，全都小写string7 = "Here's what Happens when You Use UPPER."
print("Output #35: {0:s}".format(string7.upper())) # 每一个单词的每一个字母，全都大写string8 = "here's WHAT Happens WHEN you use Capitalize."
print("Output #36: {0:s}".format(string8.capitalize())) # 第一个单词的首字母大写；同时，其余字母全部小写
print("Output #37: {0:s}".format(string8.title())) # 每一个单词的首字母大写；同时，其余字母全部小写# tittle方法的另一种实现方式【结合capitalize方法】
string8_list = string8.split() # split默认使用空格进行拆分，有几个空格就拆分几次
print("Output #37: (on each word):")
for word in string8_list: # 这里的word就是针对列表string8_list中的每个元素，新定义的变量print("{0:s}".format(word.capitalize()))
非字母开头的情况：
Python中capitalize()与title()的区别 —— 碧水幽幽泉
- capitalize方法的作用范围仅限于第一个子字符串的第一个字母
【若不是字母，则就不起作用】str2 = "深圳abc" print(str2.capitalize()) print(len(str2))
- title()方法：字符串中不管有没有空格，都将连续的字母字符 / 非字母字符视为一个单词。
【如：”abc深圳abc” 中没有用空格分隔，但也共包含3个单词，每个单词都遵循下面的四个原则。
—> 经title()方法后，结果为：Abc深圳Abc】
(1) 当某个单词的首个字符为字母时，则变为大写。【abc —> Abc】
(2) 若某个单词的首个字符为非字母字符，则保持不变。【深圳 —> 深圳】
(3) 若该单词后面还有字母，则为小写；
(4) 若该单词后面还有非字母字符，则保持不变；
【有空格时，可以理解为：空格也是非字母字符，也保持不变。】str1 = "abc深圳 深圳abc abc深圳abc abc def" print(str1.capitalize()) print(str1.title()) print(len(str1))
str2 = "abc深圳abc深圳abcdef" # 五个单词 print(str2.title()) print(len(str2))
1.4.3 正则表达式与模式匹配
Python 正则表达式详解：从基础匹配到高级应用 —— 敲代码不忘补水
# 先看不用正则的判断
pattern1 = "file"
pattern2 = "files"
string = "the file is in the folder"
print("file in string", pattern1 in string)
print("files in string", pattern2 in string)
正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。
Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。
re 模块使 Python 语言拥有全部的正则表达式功能。
Python 正则表达式 —— runoob.com
正则表达式常用的匹配符：
10分钟快速掌握正则表达式 —— 奇乐编程学院
正则表达式在线测试工具
1.4.3.1 re.compile（）
Python 中还有一个内置compile函数，其用法见：
Python compile() 函数 —— runoob.com 【Python 基础教程】
本文中仅是关于re模块中的compile函数
Python3中正则模块re.compile、re.match及re.search函数用法 —— 军刀、
compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象（ Pattern ）。即：
①用于编译正则表达式，并生成一个正则表达式对象( pattern)；
②只有通过该正则表达式对象pattern，模式字符串才能被 findall()、match() 、search()、sub()这些函数使用。
pattern.findall(string) ： 将在string中找到的所有匹配项pattern，写到一个列表中。
pattern.match(string) : 从头匹配pattern
pattern.search(string) ： 在整个字符串内匹配pattern
pattern.sub(repl,string) ： 在字符串内，将所有匹配项pattern替换为repl
用法：
第一个字符是 r，表示 raw string 原生字符，意在声明字符串中间的特殊字符不用转义。
pattern = re.compile(pattern,flags=0) 【需要r时，r写在pattern前面。】
参数pattern 指定需要编译的正则表达式【生成的pattern是编译后的正则表达式对象pattern】；
flags编译标志位，用来修改正则表达式的匹配方式。支持 re.L|re.M 同时匹配。
Python正则表达式中的re.S，re.M，re.I的作用 —— 傻白甜++
1.4.3.2 pattern.findall（string）
将在string中找到的所有匹配项，写到一个列表中。
import restring = "The quick brown fox jumps over the lazy dog."
string_list = string.split()# 查找字符串中的"The"
pattern = re.compile(r"The", re.I)
print(pattern.findall(string)) #使用 pattern.findall 将找到的所有匹配项写到一个列表中
1.4.3.3 pattern.match（string）
Python的re.match()和re.search()的使用和区别 —— 埃菲尔没有塔尖
从起始位置开始，匹配 正则表达式对象pattern，匹配成功返回一个match object对象，未匹配成功返回None.
如果不是在起始位置就匹配成功的话，即使后面还存在该对象pattern，match()仍然返回none
用法：
pattern.match(string)
pattern即指由 re.compile 编译后生成的正则表达式对象pattern
string指需要匹配的字符串
返回的是一个match objec对象 <class ‘re.Match’>，要通过group()方法来打印
import restring = "The quick brown fox jumps over the lazy dog."
string_list = string.split()# 查找字符串中的"The"
pattern = re.compile(r"The", re.I)
# print(pattern.match(string)) #可以忽略，python中要用type()查看类型
print(type(pattern.match(string)))
print(pattern.match(string).group()) #打印要使用match object对象的group方法
生成的match object对象有以下方法：
a. group() 返回被pattern匹配的字符串
b. start() 返回匹配开始的位置
c. end() 返回匹配结束的位置
d. span()返回一个元组包含匹配 (开始,结束) 的位置
1.4.3.4 pattern.search（string）
会在整个字符串内查找 正则表达式对象pattern，只要找到第一个，也返回一个match object对象；如果整个字符串都中没有该 正则表达式对象pattern，则返回None.
【所以对使用search找到的对象，都可以使用match object对象的方法。】
import restring = "The quick brown fox jumps over the lazy dog."
string_list = string.split()# 查找字符串中的"the"且区分大小写
pattern = re.compile(r"the")
print(type(pattern.search(string)))
print(pattern.search(string).group()) #同样使用match object对象的group方法打印找到的匹配
# 拓展
import restring = "The quick brown fox jumps over the lazy dog."
string_list = string.split()# 查找并计算字符串中模式The出现的次数（不处理字符串中的转义字符，不区分模式The的大小写）
pattern = re.compile(r"The",re.I)
count = 0
for word in string_list:if pattern.search(word): count += 1
print("Output #38: {0:d}".format(count))
1.4.3.5 match object.group（n）
分组是用圆括号“()”括起来的正则表达式，匹配出的内容就表示一个分组。
group（n）方法返回一个或者多个匹配的分组。
python中re的group方法详解（来自官方文档的权威解释） —— 刘大铿
如果只有一个参数，结果就是一个字符串。
如果参数值n为 0/没有参数，即是group(0)/group()，返回值就是整个匹配字符串；
如果参数值n处于 1到定义的组数 之间，返回值就是相应的匹配字符串。
如果参数值n是负数，或者大于定义的组数，就会产生索引错误。
如果有多个参数，结果就是一个元组（每个参数对应一个项）。
在下面的例子中：
group() 和 group(0)时，返回整个匹配字符串
group(1)时，返回（\d+）匹配字符串
group(2)时，返回(\w+)匹配字符串
group(1,2)时，返回由第一、二个匹配字符串（\d+）和 (\w+) 组成的元组
import recontent = 'Hello 1234567 World This is a Regex Demo'pattern = re.compile(r'^Hello\s(\d+).*(\w+)$')result = pattern.match(content)if result:print(result.group()) # 返回整个匹配字符串print(result.group(0)) # 返回整个匹配字符串print(result.group(1)) # 返回第一个匹配字符串（\d+）print (result.group(2)) # 返回第二个匹配字符串(\w+)print (result.group(1,2)) # 返回由第一、二个匹配字符串组成的元组
else:print("No match found.")
较复杂的写法：
如果在编译模式字符串的正则表达式时， 使用了 (?P< name >…) 语法来定义组合名称，那么在group(n)中，参数n就也可能是组合名称。 如果使用了未定义的组合名称，就会产生一个IndexError.import re string = "The quick brown fox jumps over the lazy dog." string_list = string.split()# 在字符串中每次找到模式时，将其打印出来(本次查找与第38次查找的规则一样) pattern = re.compile(r"(?P<match_word>The)", re.I) # 打印所有找到的所有匹配项 （方式一） print(pattern.findall(string))# 打印所有找到的所有匹配项 （方式二） print("Output #39: ") for word in string_list:if(pattern.search(word)):print("{:s}".format(pattern.search(word).group('match_word')))
还有groups() 和groupdict() 方法，具体参考：
python正则表达式精讲–分组 —— 酷python
1.4.3.6 pattern.sub（repl, string）
在字符串string内，将所有匹配项pattern替换为目标内容repl
用法：
pattern.sub(repl, string)
python re模块(正则表达式) sub()函数详解 —— leo的学习之旅
import restring = "The quick brown fox jumps over the lazy dog."
string_list = string.split()# 使用字母“a”替换字符串中的单词“the”
string_to_find = r"The"
pattern = re.compile(string_to_find, re.I)
print("Output #40: {:s}".format(pattern.sub("a",string)))
1.4.4 日期
什么是对象？对象与类的关系？对象的声明和使用 ------ deng-hui
简单通俗的说一下什么是面向过程和面向对象 ----- Hui_hui…
创建实例/对象的两种方式：
（1）通过类方法创建：赋值变量名 = 类名称.类方法名称（类方法参数）
且该对象是经过 该类方法 作用后的。如创建date类对象：today = date.today() 实例today的实例属性year、month 和 day 属性分别为：2024，9，18，表示当前日期。（2）通过类名称创建：赋值变量名 = 类名称（各实例属性值） 如创建date类对象：
day = date(2023, 11, 9) 实例day的实例属性year、month 和 day属性分别为：2023，11，9，代表2023年11月9日这个特定的日期。
调用实例方法的两种方式：
（1）实例.实例方法(参数)
（2）类名称.实例方法名称（实例，其它参数）
注意：如果想像这样通过类名直接调用实例方法，就必须手动为 self 参数传值。
即实例方法的参数不能为空，至少包含一个实例 作为类中该实例方法定义中 形参self的值。
1.4.4.1 date对象和 datetime对象之间的区别
today() 是 date类 和 datetime类中的类方法。
1.4.4.1.1 date对象
使用 date类 中的today()类方法，返回当前日期，并创建一个新的date类对象来承载该日期。再赋值给变量today.
from datetime import date,time,datetime,timedelta#打印出今天的日期形式，以及年、月、日
today = date.today()
print(today)
print("原类型：",type(today)) # <class 'datetime.date'>print("today1: {0:s}".format(today)) # 这里{:s}表示将today格式化为字符串的形式后进行输出（today的数据类型一直不变）
print("格式化后，再输出的类型：",type(today)) #仍为 <class 'datetime.date'>
#todaty1 输出的内容为s，正说明 <class 'datetime.date'>类型的日期，不能以字符串的形式输出print("Output #41: today: {0!s}".format(today)) # 要使用!s，表示在输出前调用str()，强制类型转换为字符串类型【仅限于在该语句的进程中，该语句之外，today仍为原类型】
print("强制类型转换后，再输出的类型：",type(str(today))) # <class 'str'># 强制类型转换输出后，再进行强制类型转换打印三个类属性
print("Output #42: {0!s}".format(today.year))
print("Output #43: {0!s}".format(today.month))
print("Output #44: {0!s}".format(today.day))
1.4.4.1.2 datetime对象
使用 datetime类 中的 today()类方法，返回当前日期，并创建一个新的datetime类对象来承载该日期。再赋值给变量current_datetime.
current_datetime = datetime.today()
print("Output #45: {0!s}".format(current_datetime))
1.4.4.2 使用 timedelta计算一个新日期
timedelta是模块datetime中的一个类，
其 实例属性中包含days属性，此处通过给类名称传递实参的方式，创建了一个timedelta类的实例one_day.
Python 运算符重载
浅析Python运算符重载 —— viclee108
Python运算符用于内置类。但相同的运算符对不同的类型有不同的行为。
例如，+运算符将对两个数字执行算术加法、合并两个列表并连接两个字符串。
Python中的运算符重载功能 允许同一运算符根据上下文具有不同的含义。
如果类实现了__add__方法，当类的对象出现在+运算符中时会自动调用这个方法。
两个实例是否可以直接相加，取决于这些它们所属类中是否定义了相应的运算符重载。
from datetime import date,time,datetime,timedeltatoday = date.today() # today为一个date类对象，表示当前日期
print("today类型：",type(today))# 使用timedelta计算一个新日期
one_day = timedelta(days = -1)
print("one_day类型：",type(one_day))
yesterday = today + one_day # 用到了运算重载符
print("yesterday类型：",type(yesterday))
date类支持的运算
【可见其中包括 减去一个timedelta类的时间差，结果还是属于date类。
表示从原始日期date1向前移动了指定的时间timedelta，到新日期date2. 】
datetime.date_Supported operations
timedelta类支持的运算
datetime.timedelta _Supported operations
datetime类支持的运算
【可见其中也包括 +/- 一个timedelta类的时间差，结果还是属于datetime类 】
datetime.datetime_Supported operations
from datetime import date,time,datetime,timedeltatoday = date.today() # today为一个date类对象，表示当前日期# 使用timedelta计算一个新日期
one_day = timedelta(days = -1)
yesterday = today + one_day
print("Output #46: yesterday: {0!s}".format(yesterday))eight_hours = timedelta(hours = -8)
print("Output #47: {0!s} {1!s}".format(eight_hours.days,eight_hours.seconds))
eight_hours = timedelta(hours = -8)
# 只打印秒，也不会是28800，而仍是57600
print("Output: {0!s}".format(eight_hours.seconds)) #57600
原因：
在使用 timedelta 时，它将括号中的时间差以天、秒和毫秒的形式存储，然后将数值规范化后得到一个唯一的值。
这说明：分钟、小时和星期会被分别转换成 60 秒、3600 秒和 7 天，然后规范化，生成天、秒和毫秒“列”（类似于小学数学中的个 位、十位 等等）。
因此，此处hours=-8 的输出是 (-1 days, 57,600 seconds)，不是更简单 的 (-28,800 seconds).
其计算过程为：
（1）只要hours是负值，就days就为负值。hours位于[-24,0)，那么就令days为-1，此时days被规范化完成。
（2）再规范化秒，即要使用：
86 400 秒（3600 秒每小时 *24 小时每天）-28 800 秒（3600 秒每小时 *8 小时）= 57 600 秒。这里计算的结果一定不会超过86 400.
（3）-8为整数，因此没有毫秒，其实例属性microseconds为0.
1.4.4.3 计算出两个日期之间的天数
timedelta是模块datetime中的一个类，其 实例属性 中包含days属性，此处通过给类名称传递实参的方式，创建了一个timedelta类的实例one_day.
str 函数可以 将结果转换成字符串；
split 函数可以使用空白字符将字符串拆分，并使每个子字符串成为列表的一个元素；
[0] 表示“取出列表中的第一个元素”，在本例中就是数值 1.
from datetime import date,time,datetime,timedeltatoday = date.today() # today为一个date类对象，表示当前日期one_day = timedelta(days = -1) # 使用timedelta计算一个新日期
yesterday = today + one_day# 计算出两个日期之间的天数
date_diff = today - yesterday
print("Output #48: {0!s}".format(date_diff))
print("Output #49: {0!s}".format(str(date_diff).split()[0]))
1.4.4.4 使用 strftime 函数根据一个日期对象创建具有特定格式的字符串
today是模块datetime中date 类的一个对象（实例）。
strftime是模块datetime中date 类的一个实例方法。f表示format，表示格式化。
strftime函数的作用才是将一种格式的日期字符串，转化为另一种格式的日期字符串。
【仅仅是日期格式/形式的变化】
返回值已经为string类型，不需要使用{0!s}来进行强制类型转换再输出。
此处通过 实例.实例方法(参数) 的方式来调用实例方法
from datetime import date,time,datetime,timedeltatoday = date.today() # today为一个date类对象，表示当前日期# 根据一个日期对象创建具有特定格式/形式【如strftime函数的参数'%m/%d/%Y'形式】的字符串
print("Output #50: {:s}".format(today.strftime('%m/%d/%Y')))# 验证返回值已经为string类型，不需要使用{0!s}来进行强制类型转换再输出
today_strftime = today.strftime('%m/%d/%Y')
print("today_strftime类型：",type(today_strftime))# 将日期转化为其它格式/形式
print("Output #51: {:s}".format(today.strftime('%b %d, %Y')))
print("Output #52: {:s}".format(today.strftime('%Y-%m-%d')))
print("Output #53: {:s}".format(today.strftime('%B %d, %Y')))
1.4.4.5 使用 strptime 函数根据具有特定形式的日期字符串来创建 datetime 对象
strftime是模块datetime中date 类的一个实例方法。f表示format，表示格式化。
strftime函数的作用才是将一种格式的日期字符串，转化为另一种格式的日期字符串。【仅仅是日期格式/形式的变化】
在Output #54–57中，datetime都是指模块datetime中的一个datetime 类。
strptime是datetime 类中的一个需要两个字符串参数的类方法，因此可以在没有实例的情况下被直接调用，执行与datetime 类相关的操作。
strptime函数的两个字符串参数必须完全匹配。p表示parse，表示分析。
它的主要作用是将一个日期字符串，通过分析模式，转化为与字符串形式相同的datetime 类对象（实例）并返回该实例，以便可以调用datetime 类中的类方法和实例方法。
【数据类型和所属类会发生变化，而形式一定不变。】
Output #54、55中：然后再将该strptime返回的 datetime类实例，调用 {!s}强制转换为字符串后，输出。
Output #56、57中：先用strptime类方法，把字符串date3解析为给定格式%Y-%m-%d的datetime 类对象（实例）。
之后调用datetime类中的实例方法 date，返回一个仅带 年-月-日 的datetime 类对象（实例）。
然后再将该date返回的 datetime类实例，调用 {!s}强制转换为字符串后，输出。
注意
如果想通过 类名称.实例方法名称（实例，其它参数） 的方式来直接调用实例方法，就必须手动为 self 参数传值。即实例方法的参数不能为空，至少包含一个实例 作为类中该实例方法定义中 形参self的值。
from datetime import date,time,datetime,timedeltatoday = date.today() # today为一个date类对象，表示当前日期# 根据表示日期的字符串，创建带有特殊格式的datetime对象# 这四个date为具有不同日期格式的字符串
date1 = today.strftime('%m/%d/%Y')
date2 = today.strftime('%b %d, %Y')
date3 = today.strftime('%Y-%m-%d')
date4 = today.strftime('%B %d, %Y')# 基于上述字符串，创建2个datetime对象
# 时分秒默认均为0
print("Output #54: {!s}".format(datetime.strptime(date1, '%m/%d/%Y')))
print("Output #55: {!s}".format(datetime.strptime(date2, '%b %d, %Y')))# 基于上述字符串，创建2个datetime对象，但仅显示日期部分
print("Output #56: {!s}".format(datetime.date(datetime.strptime(date3,'%Y-%m-%d'))))
print("Output #57: {!s}".format(datetime.date(datetime.strptime(date4,'%B %d, %Y'))))
