Python 记录（一）

记录一些Python中遇到的零碎知识点~

1.字符串替换、删除字符

使用maketrans()创建映射词典，然后使用translate()将映射应用在字符串中：

str01 = 'qwe-as-0d'
intab = 'qwe'
outab = 'asd'
deltab = 'd'
trantab = str01.maketrans(intab, outab, deltab)
print(type(trantab))
print(trantab)
print(str01.translate(trantab))

输出：

<class 'dict'>
{113: 97, 119: 115, 101: 100, 100: None}
asd-as-0

可以看到，其实是对字符进行了一个映射，然后对字符串应用这个映射规则。

2.字符串前的’b’, ‘r’, ‘u’

3.关于set的操作

Python提供了关于交集、并集等集合运算的函数，例如 difference()函数

a = set([1,2,3,4])
b = set([3,4,5,6,7])
a = a.difference(b)
print(a)

output：
{1, 2}

也就是集合相减，结果为第一个集合独有的元素。

4.关于re.split()分割字符串

相较于str.split()简单分割字符串， re.split()显然可以通过正则匹配的方式进行字符串分割，例如如果按照 “或” 的方式对字符串进行分割：

import re

str01 = "hello?but!yes.No"
res = re.split(r'[?!.]', str01)
print(res)

output：
['hello', 'but', 'yes', 'No']

可以看到split的参数pattern是一个正则式子，表示可以使用其中任意的一个字符进行分割。

5.关于Python表示多行字符串

使用( )符号，例如：

text = ('abc'
        'def'
        'ghi')

print(text)

注意两行之间没有符号

6.错误：Error occurred during initialization of VMCould not reserve enough space for object heap

由于使用pyhanlp创建了Java 虚拟机，这个错误是因为可用空间小于JVM的分配内存，可以设置Java虚拟机的内存小一点，也可以手动清理一些不必要的程序。参考：Error occurred during initialization…

7.关于列表解析式的二重循环以及二维列表的 生成

使用二重循环的列表生成式生成列表，例如：

text = ['1', '2', '3']

res = [i+j for i in text for j in text]
print(res)

output：
['11', '12', '13', '21', '22', '23', '31', '32', '33']

注意两个循环的表现方式，其实就跟写出正常循环一样，先写第一层循环，然后是第二层循环的语句。
但是这样按照循环的顺序却很难实现二维列表的实现，如果我们交换两个循环的顺序，则可以实现二位列表的生成，例如：

a = ['a', 'b', 'c']
b = [i+j for i in a for j in a]
print(b)
c = [[j+'1' for j in i]  for i in a]
print(c)

输出为：

['aa', 'ab', 'ac', 'ba', 'bb', 'bc', 'ca', 'cb', 'cc']
[['a1'], ['b1'], ['c1']]

个人觉得这样的方式还是挺有用的。

8.通过正则表达式过滤制定符号

text2 = "最美的不是下雨天，是曾与你躲过雨的屋檐。"
comp = re.compile('[，。！：]')
text2 = comp.sub('', text2)
print(text2)

output:
最美的不是下雨天是曾与你躲过雨的屋檐

9.使用filter

filter调用格式：

filter(rule, seq)

对于seq中的每一个元素，都使用 rule 函数的规则进行判断，返回一个 filter 对象，可以使用 list()转化为列表：

x = np.random.randint(1, 20, 10)

def judge(n):
    return n%2==0

res = filter(judge, x)    # 返回x中所有可以被 2 整除的数字 
print(x)
print(list(res))

10.使用 isinstance()函数判断对象类型

例如：

a = 'abc'
print(isinstance(a, int))
print(isinstance(a, str))           # 可以判断是否为某一种类型
print(isinstance(a, Iterable))   # 判断是否为 可迭代对象
print(isinstance(a, (int, str)))   # 也可以使用元组的形式传入多种类型 满足其中一种即返回 True

输出：

False
True
True
True

11.输出指定位数的浮点数

有多种方式，可以使用与C语言一样的控制方式：

a = 2.333333
print(a)
print("a= %f" % (a))
print("a= %.2f" % (a))

输出：

2.333333
a= 2.333333
a= 2.33

12.在函数中对全局变量进行改动

函数中使用全局变量并进行改动要使用global关键词，只是使用值的话可以直接使用：

a = 3
def test():
    global a       # 去掉会报错
    a += 2
    print(a)  
test()

13.Python中关于列表以及迭代器的生成

注意使用列表解析式的方式进行生成时，使用[ ]生成列表，使用( )生成迭代器，例如：

a = list(range(5))
b = [i*2 for i in a]
c = (i*3 for i in a)

print(type(b))
print(type(c))

输出：
<class 'list'>
<class 'generator'>

14. zip函数

使用zip函数可以将列表等可迭代对象打包在一起，如果对象的长度不一致，那么会以最短长度为准，例如：

a = [1, 2, 3]
b = [4, 5, 6]

res = zip(a, b)

# print(list(res))

for first, second in res:
    print(first, second)

输出结果：

1 4
2 5
3 6

这里注意，返回的结果（例如上面的res）是类似迭代器的，所以有点“一次性”的意思，如果上面的代码将print...部分注释去掉，可以看到只是循环输出了一遍。

15.re模块的findall()函数

re模块下的findall（）函数有两种调用形式：

text = 'qwer12sadf34xc54df'
p1 = re.compile(r'\d+')
res_list = p1.findall(text)
print(res_list)

# 或者
text = 'qwer12sadf34xc54df'
p1 = re.compile(r'\d+')
res_list = re.findall(p1, text)
print(res_list)

实际上区别并不大。。。函数的意义就像函数名一样，查找所有的匹配字符串，然后返回一个list。
PS：注意 \w 在正则表达式中表示单词字符，有些网站上介绍包括英文字符以及数字，但是中文字符不匹配，在Python中试了一下，发现中文字符也是匹配的。

16.np.random.choice()函数

使用这个函数需要引入 random 模块，此函数可以从指定的列表（数组）中随机抽取数据，函数调用格式：

def choice(a: Any,     # 1-D的数组
           size: Union[int, Iterable, tuple[int], None] = None,    # 要生成的结果数组的尺寸
           replace: Optional[bool] = True,       # 是否是有放回抽样
           p: Any = None) -> Any        # 可以提供一个权重数组

例如：

import random

arr = np.array([1,2,3,4])
res1 = np.random.choice(arr, 3, replace=False)
res2 = np.random.choice(arr, 3, replace=True)

print(res1)
print('-'*20)
print(res2)

输出：

[3 1 2]
--------------------
[4 4 1]

17.关于sys.setdefaultencoding()

有些老一点的代码会有这个函数，在Python3中，由于默认的编码方式就是UTF-8，所以移除了这一函数

18.关于生成指定范围的随机序列

使用np.random.permutation()函数，例如，指定从0开始的数字：

indices = np.random.permutation(5)
print(indices)

这是将0-4生成随机序列，也可以直接指定一个列表：

ran = [1,5,6,4]
ran_shuffle = np.random.permutation(ran)

可以使用这个函数来打乱训练数据。例如：

def batch_iter(x, y, batch_size=64):
    data_len = len(x)
    num_batch = int((data_len-1) / batch_size) + 1   # 计算在batch_size大小下一个epoch取完要多少次

    indices = np.random.permutation(np.arange(data_len))
    x_shuffle = x[indices]                                          # 按照打乱的序列重新组成数组
    y_shuffle = y[indices]

    for i in range(num_batch):
        start_id = i * batch_size
        end_id = min((i+1)*batch_size, data_len)                  # 注意一定要有min比较 最后一次可能不是整除
        yield x_shuffle[start_id: end_id], y_shuffle[start_id:end_id]  # 生成器方式生成训练数据

19.一种遍历多维数组的方式

直接指定每一行的元素：

import numpy as np

a = np.random.randint(1, 10, (2,3))

for i, j, k in a:       # 直接指定每一行的遍历中所有的元素
    print(i, j, k)

输出：

7 8 2
6 3 6

20.使用指定长度的双端队列

使用collections 模块下的 deque，可以建立双端队列，在保存一定长度的数据的时候可用，例如：

import collections

arr = np.array([1,2,3,4,5])
que = collections.deque(maxlen = 3)

for item in arr:
    que.append(item)
    print('setp: ', i, ' : ', que)

输出如下：

setp:  1  :  deque([1], maxlen=3)
setp:  2  :  deque([1, 2], maxlen=3)
setp:  3  :  deque([1, 2, 3], maxlen=3)
setp:  4  :  deque([2, 3, 4], maxlen=3)
setp:  5  :  deque([3, 4, 5], maxlen=3)

可以看到，如果队列中长度未达到 maxlen 那么数据可添加，如果已经达到了最大长度，那么继续添加新元素会“挤”掉队列最前面的元素。