Python正式课第十四天

作者: code与有荣焉 | 来源:发表于2019-11-21 19:33 被阅读0次

Python常用模块

一、时间处理模块

1. time.time()

time time() 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。

import time
print(time.time())

在Python的时间处理模块中,time模块只用time.time()时间戳、time.sleep()程序睡眠这两个，剩下的功能用datetime模块就行。

datetime主要由五个模块组成：

datetime.date：表示日期的类。常用的属性有year, month, day。
datetime.time：表示时间的类。常用的属性有hour, minute, second, microsecond（微秒）。
datetime.datetime：表示日期+时间。（使用的最多）
datetime.timedelta：表示时间间隔，即两个时间点之间的长度，常常用来做时间的加减。（常常被用来修改时间）
datetime.tzinfo：与时区有关的相关信息。

2. datetime.datetime

class datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)

3. datetime类方法

这些方法大多数用来生成一个datetime对象。

import datetime

datetime.today()

获取今天的时间。

In [1]: datetime.datetime.today()
Out[1]: datetime.datetime(2018, 7, 2, 15, 5, 17, 127663)

datetime.now(tz=None)
获取当前的时间。

In [2]: datetime.datetime.now()
Out[2]: datetime.datetime(2018, 7, 2, 15, 8, 30, 593801)

datetime.fromtimestamp(timestamp, tz=None)
用一个时间戳来生成datetime对象。
注：时间戳需要为10位的

In [3]: datetime.datetime.fromtimestamp(1530515475.18224)
Out[3]: datetime.datetime(2018, 7, 2, 15, 11, 15, 182240)

4. datetime实例方法

这些方法大多是一个datetime对象能进行的操作。

datetime.date() 和 datetime.time()
获取datetime对象的日期或者时间部分。

In [1]: datetime.datetime.now().date()
Out[1]: datetime.date(2018, 7, 2)

In [1]: datetime.datetime.now().time()
Out[1]: datetime.time(15, 24, 37, 355514)

datetime.replace(year=self.year, month=self.month, day=self.day, hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, * fold=0)
替换datetime对象的指定数据。

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

In [2]: now
Out[2]: datetime.datetime(2018, 7, 2, 15, 26, 45, 116239)

In [3]: now.replace(year=2000)
Out[3]: datetime.datetime(2000, 7, 2, 15, 26, 45, 116239)

datetime.timestamp()
转换成时间戳。

In [1]: datetime.datetime.now().timestamp()
Out[1]: 1530515994.798248

datetime.weekday()
返回一个值，表示日期为星期几。0为星期一，6为星期天。

In [1]: datetime.now().weekday()
Out[1]: 1

5. datetime.timedelta

datetime.timedelta这个模块使能够非常方便的对时间做加减。

datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

In [1]: from datetime import timedelta

In [2]: now
Out[2]: datetime.datetime(2018, 7, 2, 15, 26, 45, 116239)

In [3]: now - timedelta(days=1)
Out[3]: datetime.datetime(2018, 7, 1, 15, 26, 45, 116239)

In [4]: now + timedelta(days=1)
Out[4]: datetime.datetime(2018, 7, 3, 15, 26, 45, 116239)

In [5]: now + timedelta(days=-1)
Out[5]: datetime.datetime(2018, 7, 1, 15, 26, 45, 116239)

6. strftime() 和 strptime()

datetime.strftime()
由datetime转换成字符串
strftime()是datetime对象的实例方法：

In [1]: datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S %f')
Out[1]: '2018-07-02 15:26:45 116239'

datetime.datetime.strptime()
由字符串转换成datetime
strptime()则是一个类方法：

In [1]: newsTime='Sun, 23 Apr 2017 05:15:05 GMT'

In [2]: GMT_FORMAT = '%a, %d %b %Y %H:%M:%S GMT'

In [3]: datetime.datetime.strptime(newsTime,GMT_FORMAT)
Out[3]: datetime.datetime(2017, 4, 23, 5, 15, 5)

以下是格式化的符号：

%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

注意：
区分strptime和strftime:
str-format-time和str-parse-time
格式化为字符串和解析为datetime对象

二、目录操作模块

1. 获取当前工作目录

import sys

print(sys.path[0])

2. 获取执行命令的位置

os 是 操作系统 的意思

import os

print(os.getcwd())

3. 路径拼接

由于不同的操作系统的路径分隔符不同，因此在做路径拼接时不要直接拼接字符串，而是通过 os.path.join() 函数，如下：

import os

os.path.join('/Users/pangao', 'test.txt')

# /Users/pangao/test.txt'

注意：

在linux中拼接是'/',windows中拼接是'\'
os.sep 可以获取当前操作系统的分隔符

4. 路径拆分

同理，使用 os.path.split() 函数拆分路径
os.path.split()可以把路径拆分成路径和文件

import os

os.path.split('/Users/pangao/test.txt')

# ('/Users/pangao/', 'test.txt')

os.path.splitext() 可以直接获取文件扩展名
os.path.splitext()可以用来取拓展名

import os

os.path.splitext('/Users/pangao/test.txt')

# ('/Users/pangao/test', '.txt')

5. 文件重命名

假定当前目录下有一个 test.txt 文件

import os

os.rename('test.txt', 'test.py')    #重命名

6. 删除文件

import os

os.remove('test.txt')    #删除

7. 复制文件

import shutil

shutil.copyfile('test.txt', 'test.py')

8. 遍历文件夹下的文件

方法1：使用 os.listdir 获取当前目录下的文件和文件夹，如下：
.是当前目录 ..是上一级目录

import os

for filename in os.listdir('./'):
    print(filename)

方法2：使用 glob 模块，可以设置文件过滤，如下：

import glob

for filename in glob.glob('*.py'):
    print(filename)

方法3：通过 os.walk ，可以访问子文件夹，如下：

# 获取所有文件的路径
import os

for fpathe, dirs, fs in os.walk('./'):
    print(fpathe)
    print(dirs)
    print(fs)
    for f in fs:
        print(os.path.join(fpathe, f))

9. 判断文件是否存在

import os

os.path.isfile('test.txt') # 如果不存在就返回False

10. 判断目录是否存在

import os

os.path.exists(directory) #如果目录不存在就返回False

三、随机数模块

random模块

Python中产生随机数需要导入random模块

import random

随机数模块常用方法

random.randint(a, b)：返回a和b之间的随机整数

>>> import random
>>> random.randint(0, 10)
8
>>> random.randint(0, 10)
7
>>> random.randint(0, 10)
10
>>>

random.random()：返回０到１之间随机数（不包括1）

>>> random.random()
0.8836361984681352
>>> random.random()
0.013648077769505496
>>> random.random()
0.7267135453127417
>>>

random.choice(seq)：在不为空的序列中随机选择一个元素

>>> s = 'helloWorld'
>>> random.choice(s)
'o'
>>> random.choice(s)
'r'

random.sample(population, k)：在一个序列或者集合中选择k个随机元素()，返回由K个元素组成新的列表；（k的值小于population的长度）

>>> random.sample('12345', 2)
['1', '2']
>>> random.sample('12345', 5)
['2', '1', '3', '4', '5']
>>> random.sample('12345', 6)    #k值超出population范围导致程序异常
Traceback (most recent call last):
  File "<pyshell#41>", line 1, in <module>
    random.sample('12345', 6)
  File "D:\python36\lib\random.py", line 317, in sample
    raise ValueError("Sample larger than population or is negative")
ValueError: Sample larger than population or is negative
>>>

random.uniform(a, b)：产生一个指定范围内的随机浮点数若a < b，随机数n范围：a <= n <= b；若a > b，随机数n范围：a<= n <= b；

random.uniform(a, b)：产生一个指定范围内的随机浮点数 若a < b，随机数n范围：a <= n <= b； 若a > b，随机数n范围：a<= n <= b；

random.randrange(start, stop=None, step=1, _int=) ：在rang(start, stop,step)中选择一个随机数

>>> random.randrange(1, 10, 1)   #[1,10)之间随机整数
5
>>> random.randrange(1, 10, 1)
2
>>> random.randrange(1, 100, 2)  #[1, 100)之间随机奇数
33
>>> random.randrange(1, 100, 2)
5

random.shuffle(x, random=None)：将列表顺序打乱

>>> l = ['C', 'C++', 'Java', 'C#', 'Python']
>>> random.shuffle(l)
>>> l
['C++', 'C', 'Java', 'C#', 'Python']
>>> random.shuffle(l)
>>> l
['C', 'Python', 'C++', 'C#', 'Java']
>>>

四、Collections模块

该模块实现了专门的容器数据类型，为Python的通用内置容器提供了替代方案。以下几种类型用的很多：

defaultdict (dict子类调用工厂函数来提供缺失值)
counter (用于计算可哈希对象的dict子类)
deque (类似于列表的容器，可以从两端操作)
namedtuple (用于创建具有命名字段的tuple子类的工厂函数)
OrderedDict (记录输入顺序的dict)

1. defaultdict（缺省字典）

其实就是一个查不到key值时不会报错的dict
正常的字典查不到key值会报错
示例：

from collections import defaultdict
person = defaultdict(lambda : 'Key Not found') # 初始默认所有key对应的value均为‘Key Not Found’

person['name'] = 'xiaobai'
person['age'] = 18

print ("The value of key  'name' is : ",person['name'])
print ("The value of key  'adress' is : ",person['city'])

Out：The value of key  'name' is :  xiaobai
     The value of key  'adress' is :  Key Not found

还可以默认所有key对应的是一个list，就可以在赋值时使用list的append方法了。
示例：

from collections import defaultdict
food = (
    ('jack', 'milk'),
    ('Ann', 'fruits'),
    ('Arham', 'ham'),
    ('Ann', 'soda'),
    ('jack', 'dumplings'),
    ('Ahmed', 'fried chicken'),
)

favourite_food = defaultdict(list)

for n, f in food:
    favourite_food[n].append(f)

print(favourite_food)

Out：defaultdict(<class 'list'>, {'jack': ['milk', 'dumplings'], 'Ann': ['fruits', 'soda'], 'Arham': ['ham'], 'Ahmed': ['fried chicken']})

2. counter

就是一个计数器，一个字典，key就是出现的元素，value就是该元素出现的次数
示例：

from collections import Counter

count_list = Counter(['B','B','A','B','C','A','B','B','A','C'])  #计数list
print (count_list)


count_tuple = Counter((2,2,2,3,1,3,1,1,1))  #计数tuple
print(count_tuple)

Out：Counter({'B': 5, 'A': 3, 'C': 2})
     Counter({1: 4, 2: 3, 3: 2})

Counter一般不会用于dict和set的计数，因为dict的key是唯一的，而set本身就不能有重复元素

3. deque（双端队列）

deque就是一个可以两头操作的容器，类似list但比列表速度更快
deque的方法有很多，很多操作和list类似:

支持索引取值，但不支持切片操作
支持append()、extend()、len()等
支持pop(),但不支持pop(0)
可以popleft() # 删除并返回最左端的元素
可以appendleft(100) # 从最左端添加元素
定义一个deque时可以规定它的最大长度maxlen
示例：

from collections import deque
d = deque([1,2,3,4,5], maxlen=9)  #设置总长度不变
d.extendleft([0])  # 从左端添加一个list
d.extend([6,7,8])   # 从右端拓展一个list
print(d)

Out：deque([0, 1, 2, 3, 4, 5, 6, 7, 8], maxlen=9)

d.append(100)
print(d)
d.appendleft(-100)
print(d)

Out: deque([1, 2, 3, 4, 5, 6, 7, 8, 100], maxlen=9)
     deque([-100, 1, 2, 3, 4, 5, 6, 7, 8], maxlen=9)

现在d已经有9个元素了，而规定的maxlen=9，这个时候如果从左边添加元素，会自动移除最右边的元素，反之也是一样

4. namedtuple（命名元组）

命名元组。大家一看名字就会和tuple元组有关，没错，它是元组的强化版。namedtuple可以将元组转换为方便的容器。使用namedtuple，不必使用整数索引来访问元组的成员。
觉得可以把namedtuple 视为不可变的字典
示例：

from collections import namedtuple

Person = namedtuple('Person', 'name age city')        # 类似于定义class
xiaobai = Person(name="xiaobai", age=18, city="paris") # 类似于新建对象
print(xiaobai)

Out：Person(name='xiaobai', age=18, city='paris')

创建namedtuple时非常像定义一个class，这里Person好比是类名，第二个参数就是namedtuple的值的名字了，很像class里的属性，不过这里不用加逗号分离

访问namedtuple的成员

print(xiaobai.name)
print(xiaobai.age)
print(xiaobai.city)

out：xiaobai
     18
     paris

注意：
不能修改namedtuple里的值

5. OrderedDict（有序字典）

会记录插入dict的key和value的顺序
不过现在字典已经自动就是有序的，所以OrderedDict用不上了。

五、pickle模块（很有用）

python对象的序列化与反序列化
特点：

只能在python中使用，只支持python的基本数据类型。
可以处理复杂的序列化语法。（例如自定义的类的方法，游戏的存档等）

内存中操作： dumps方法将对象转成字节（序列化） loads方法将字节还原为对象（反序列化）

import pickle
#dumps
li = [11,22,33]
r = pickle.dumps(li)
print(r)


#loads
result = pickle.loads(r)
print(result)

文件中操作

#dump：
import pickle

li = [11,22,33]
pickle.dump(li,open('db','wb'))

#load
ret = pickle.load(open('db','rb'))
print(ret)

注意：
需要在序列化和反序列化定义相同的函数名称，但内容可以不一样
序列化的其实只是函数名，最后调用时其实调用的是当前文件中同名函数的内容

六、综合实例---猜数游戏

import random
import pickle
from collections import deque

n = random.randint(0, 100)  # 随机找出0-100之中的数
history_list = deque([], maxlen=5)  # 限制最大长度
try_num = 0
print(n)


def pk(m):
    if m != n:
        if m > n:
            print("大了")
        else:
            print("小了")
        return False
    return True


def h_print():# pickle取
    ret = pickle.load(open('history', 'rb'))
    return ret


def history(history_list): # pickle存
    history_list = list(history_list)
    pickle.dump(history_list, open('history', 'wb'))


while True:
    try_num += 1
    if try_num > 10:
        print("尝试次数过多，您已经笨死了！！！")
        break
    m = input("输入您的答案:")
    try:                               # 异常处理 防止用户输入字母
        # m = input("输入您的答案:")
        if len(m) == 0:
            print("not null")
        m = int(m)
        history_list.append(m)
        history(history_list)
        if pk(m) == True:
            print("以您的智商，居然TM答对了")
            break
    except ValueError:
        if m == "h":
            print("您猜数的历史记录：")
            print(h_print())
        else:
            print("格式有误，请输入整数字")