《Python数据分析基础》第一章-Python基础（1.4-1.4.4）

Flerken101

已于 2024-10-08 01:18:35 修改

阅读量809

点赞数 15

分类专栏：《Python数据分析基础》文章标签： python 数据分析开发语言

于 2024-09-17 20:19:53 首次发布

本文链接：https://blog.csdn.net/qq_44883214/article/details/142318270

版权

《Python数据分析基础》专栏收录该内容

4 篇文章 0 订阅

订阅专栏

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：通常为一个整形/浮点型数值，或为字符串String
print(int('0xa',16)) 
print(int('1010',2)) 

1.4.1.2 浮点数

python基础_格式化输出（%用法和format用法）——fat39

61-python基础-python3-格式化浮点数方法-%e、%f、%g——Summer儿

a.bf ：a表示浮点数的长度，b表示浮点数小数点后面的精度
当a = 0，b ≠ 0时，整数部分按原值输出，小数部分四舍五入保留b位；
当a = 0，b = 0时，没有小数部分，整数部分四舍五入第一位小数后输出。

当a ≠ 0，b = 0时：
如果a小于原来数值（包括小数位）的长度，那么将原值第七位四舍五入，保留六位小数后输出。
如果a大于原值的长度，那么就在原值左侧用空格补齐不足位，保留六位小数后输出。

当a ≠ 0，b ≠ 0时，
如果a小于原值的长度，那么将原值第b+1位四舍五入，保留b位小数后输出。
如果a大于原值的长度，那么就在原值左侧用空格补齐不足位，保留b位小数后输出。

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 cbrt

print(pow(1000,1/3))  
# 输出：9.999999999999998

a = 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四舍五入到整数后的结果；如果不是，则打印原始结果。
# 输出：10

print(cbrt(1000))
# 输出：10.0

number = 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，以此类推。
当有时候弄不清最后一个元素，或只想取最后几个元素时，可以用这个方法。

函数 join 的作用都是进行字符串的拼接，出处不同的join用法也不同。

# 这里的join是Python的内置函数 
print("Output #25: {0}".format(",".join(string2_list))) 
# 内置函数  join 函数使用 , 将列表string2_list中的元素（子字符串）组合成一个字符串 

# 这里的join是os模块，path类中的方法 
allpath = os.path.join(inputPath, ' *.txt')    
# 方法join也是进行字符串的拼接，返回值将path = inputPath 和 *paths = ' *.txt' 拼接起来的字符串

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))

# 字符串最两端的所有的字符【空白字符（空格、制表符和换行符）及其它字符】都可删除，而且对在strip函数参数中列出的顺序没有严格要求
string4A = "$$  Remove unwanted characters  *  from this string.--++\t\t     \n"
print("Output #26: string4A: {0:s}".format(string4A))

string4A_strip = string4A.strip('\t $*-+\n')  # 除了位于字符串中间的*号都删除了
print("Output #26: string4A: {0:s}".format(string4A_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 re

string = "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 re

string = "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 re

string = "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 re

string = "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 re

content = 'Hello 1234567 World This is a Regex Demo'

pattern = re.compile(r'^Hello\s(\d+).*(\w+)$')
# 这里pattern匹配的是整个content字符串，其中包含两个用()括起来的分组

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) 
#匹配字符串中的the，不区分大小写，并将匹配到的所有内容保存在名称为match_word的组合中

# 打印所有找到的所有匹配项 （方式一）
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 re

string = "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…

在 Python 中，类中可以包含 类方法 和 实例方法 两类方法，
包括 类属性 和 实例属性 两种属性。

（1）类方法和类属性

类方法通常用于执行与类相关的操作，如访问和修改类级别的属性和方法。

类方法能够操作类本身，而不需要创建实例，即类方法可以在没有实例的情况下被调用。

类方法不能直接访问实例属性。必须要先创建实例，然后通过实例访问实例属性。

类方法以 cls 作为第一个参数，如__new__方法。
__new__方法是Python新式类引入的，__new__通常用于控制生成一个新实例的过程。
它是类级别的静态方法，在创建实例对象前执行，如果自定义类中没有重写该方法，则Python自动调用父类的方法，当所有父类也没有重写定义该方法时，则直接调用object类的__new__方法。

（2）类的实例、实例方法、实例属性

创建类的实例/对象的两种方式：
（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的值。

也仅可通过类的实例访问实例属性。

实例方法以 self 作为第一个参数，如__init__方法。

区别：
__new__方法是在实例对象创建时执行的，而构造方法__init__是实例创建后执行的。

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'>

# 强制类型转换输出后，再进行强制类型转换打印三个类属性
# 因为这三个类属性都是int数据类型，因此也可用:d直接输出
print("Output #42: {0!s}".format(today.year))
# 或者使用print("Output #42: {0:d}".format(today.year))
print("Output #43: {0!s}".format(today.month))
# 或者使用print("Output #43: {0:d}".format(today.month))
print("Output #44: {0!s}".format(today.day))
# 或者使用print("Output #44: {0:d}".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,timedelta

today = 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,timedelta

today = 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))
# 前一天的第57600秒，即从现在数起，过去的第28800秒

在这里插入图片描述

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,timedelta

today = 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,timedelta

today = 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,timedelta

today = 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'))))