python+AI第十一课

随机数模块

随机数模块常用方法
random.randint(a, b)，返回a和b之间的随机整数

import random
a = random.randint(0, 10)
b = random.randint(0, 10)
c = random.randint(0, 10)
print(a, b, c)
# 3 5 10

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

import random
a = random.random()

b = random.random()

c = random.random()
print(a, b, c)
# 0.6757757532603484 
# 0.1256660764957097 
# 0.3954464140289171

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

s = 'helloworld'
print(random.choice(s))
# l

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

print(random.sample('12345', 2))
print(random.sample('12345', 5))
# ['4', '2']
# ['4', '3', '1', '5', '2']

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

print(random.uniform(1,10))
# 1.9304756617571137
print(random.uniform(10, 1))
# 2.872422460231057

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

print(random.randrange(1,100,1))
# 84 [1,100)之间随机整数
print(random.randrange(1,100,2))
# 91 [1, 100)之间随机奇数

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

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

Collections模块

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

• defaultdict (dict子类调用工厂函数来提供缺失值)
  查不到key值时不会报错的dict

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

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

还可以利用defaultdict创建时，传递参数为所有key默认value值这一特性，实现一些其他的功能

from collections import defaultdict
d = defaultdict(list)
d['person'].append("xiaobai")
d['city'].append("paris")
d['person'].append("student")

for i in d.items():
    print(i)

# ('person', ['xiaobai', 'student'])
     ('city', ['paris'])

• counter (用于计算可哈希对象的dict子类)
  Counter是dict的子类。因此，它是一个无序集合，其中元素及其各自的计数存储为字典。就是一个计数器，一个字典，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)
# Counter({'B': 5, 'A': 3, 'C': 2})
# Counter({1: 4, 2: 3, 3: 2})

• deque (类似于列表的容器，可以从两端操作)
  在需要在容器两端的更快的添加和移除元素的情况下，可以使用deque

from collections import deque
d = deque()
d.append(1)
d.append(2)
d.append(3)
print(len(d))
print(d[0])
print(d[-1])
# 3
# 1
# 3

• namedtuple (用于创建具有命名字段的tuple子类的工厂函数)
  命名元组。大家一看名字就会和tuple元组有关，没错，它是元组的强化版。namedtuple可以将元组转换为方便的容器。使用namedtuple，不必使用整数索引来访问元组的成员。

from collections import namedtuple

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

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

• OrderedDict (记录输入顺序的dict)基本不再使用

pickle模块

python对象的序列化与反序列化
特点
1.只能在python中使用，只支持python的基本数据类型。
2.可以处理复杂的序列化语法。（例如自定义的类的方法，游戏的存档等）
一、内存中操作： 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)

三、练习：

pickle的序列化： 格式：pickle.dumps(序列化对象)
import pickle
test = r'test.txt'

反序列化代码中也要定义相同的函数名称，函数体没限制

def sayhi(name):
    print("hello",name)

info = {
    '':'',
    'age':32,
    'func':sayhi
}

print(pickle.dumps(info))

with open(test,'wb') as f:
    f.write( pickle.dumps(info) )

pickle反序列化： 格式：pickle.loads(读取文件逐行记录)

import pickle

test = r'test.txt'

#需要定义序列化代码中同样的函数名，函数体没限制
def sayhi(name):
    print("hello",name)
    print("hello2",name)

with open(test,'rb') as f:
    data = pickle.loads(f.read())
    print('data>>>',data)
print(data['func']("Alex"))
data>>> {'': '', 'age': 32, 'func': <function sayhi at 0x000000000231C1E0>}
hello Alex
hello2 Alex
None

注意： 1.print(data'func')
调用了pickle的反序列化变量data。
2.需要在序列化和反序列化定义相同的函数名称，但内容可以不一样。否则报错如下：

AttributeError: Can't get attribute 'sayhi' on <module '__main__'
写入文件并序列化

格式：pickle.dump(序列对象变量，文件名)

import pickle
test = r'test.txt'
#反序列化代码中也要定义相同的函数名称，函数体没限制
def sayhi(name):
    print("hello",name)
info = {
    '':'',
    'age':32,
    'func':sayhi
}
print(pickle.dumps(info))
with open(test,'wb') as f:
    #f.write( pickle.dumps(info) )
    pickle.dump(info,f)  #跟上面的f.write( pickle.dumps(info) )语意完全一样。

从文件中读取，并反序列化： 格式：pickle.load(文件名)

import pickle
test = r'test.txt'
#需要定义序列化代码中同样的函数名，函数体没限制
def sayhi(name):
    print("hello",name)
    print("hello2",name)
with open(test,'rb') as f:
    # data = pickle.loads(f.read())
    data = pickle.load(f)  #跟上面的data = pickle.loads(f.read())语意完全一样。
    print('data>>>',data)
print(data['func']("Alex"))