python数据处理常用函数整理

1.python中np.array(),np.arange(),np.range(),numpy.random.rand(), numpy.random.randn(),numpy.random.randint()

import numpy as np

#np.array()
#np.array构造函数
#用法：np.array([1,2,3,4,5]) 
d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype=np.float)#浮点型
d.astype(int)#强转
#arange()
用法 ：np.arange(0,10)  #生成[0,1,2,3,4,5,6,7,8,9] 左开右闭不包括10

#arange 和python 的range 函数的区别
#arange可以生成浮点类型，而range只能是整数类型
range(start, stop[, step])
>>>range(10)        # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)     # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)  # 步长为 5
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)  # 步长为 3
[0, 3, 6, 9]
>>> range(0, -10, -1) # 负数
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

#reshape
np.arange(1,10).reshape((3,3)) 从(3,4)改为(4,3)并不是对数组进行转置，而只是改变每个轴的大小，数组元素在内存中的位置并没有改变
reshape(-1,1) 任一行一列

#构造等差数列
np.linspace(1, 10, 10)
#构造等差数列 开始值，结束值，共几个数字 
#包括终止值 [1,2,3,4,5,6,7,8,9,10]
#可以通过选项配置其不包括终止值
c=np.linspace(1, 10, 10, endpoint=False)

#构造等比数列
np.logspace(1,4,4,base=2,endpoint=True)


#rand()
np.random.rand(4,2) #shape4*2
>>array([[ 0.02173903,  0.44376568],
       [ 0.25309942,  0.85259262],
       [ 0.56465709,  0.95135013],
       [ 0.14145746,  0.55389458]])
np.random.rand(4,3,2) # shape: 4*3*2

#randn,正态分布
#标准正态分布又称为u分布，是以0为均值、以1为标准差的正态分布，记为N（0，1）
np.random.randn() # 当没有参数时，返回单个数据
>>-1.1241580894939212

np.random.randn(2,4)
>>array([[ 0.27795239, -2.57882503,  0.3817649 ,  1.42367345],
       [-1.16724625, -0.22408299,  0.63006614, -0.41714538]])

#numpy.random.randint(low, high=None, size=None, dtype=’l’)
np.random.randint(1,size=5) # 返回[0,1)之间的整数，所以只有0
>>array([0, 0, 0, 0, 0])
np.random.randint(1,5) # 返回1个[1,5)时间的随机整数
>>4
np.random.randint(-5,5,size=(2,2))
>>array([[ 2, -1],
       [ 2,  0]])

2.python中[-1]、[:-1]、[::-1]、[2::-1]以及np.argsort使用方法

import numpy as np
a=[1,2,3,4,5]
print(a)
[ 1 2 3 4 5 ]
print(a[-1]) ###取最后一个元素
[5] 
print(a[:-1])  ### 除了最后一个取全部
[ 1 2 3 4 ]
 
print(a[::-1]) ### 取从后向前（相反）的元素
[ 5 4 3 2 1 ] 
print(a[2::-1]) ### 取从下标为2的元素翻转读取
[ 3 2 1 ]

x=np.array([1,4,3,-1,6,9])

#argsort()函数的具体功能：
#argsort()函数是将x中的元素从小到大排列，提取其对应的index(索引)，然后输出
x.argsort()
[3,0,2,1,4,5]
#例如：x[3]=-1最小，所以y[0]=3,x[5]=9最大，所以y[5]=9。

3.random.seed()

seed()方法改变随机数生成器的种子，可以在调用其他随机模块函数之前调用此函数

import random
random.seed( [x] )

注意：seed()是不能直接访问的，需要导入random模块，然后通过random静态对象调用该方法

import random

# 随机数不一样
random.seed()
print('随机数1：',random.random())
random.seed()
print('随机数2：',random.random())

# 随机数一样
random.seed(1)
print('随机数3：',random.random())
random.seed(1)
print('随机数4：',random.random())
random.seed(2)
print('随机数5：',random.random())

'''
随机数1： 0.7643602170615428
随机数2： 0.31630323818329664
随机数3： 0.13436424411240122
随机数4： 0.13436424411240122
随机数5： 0.9560342718892494
'''

 可以看到当seed()没有参数时，每次生成的随机数是不一样的，而当seed()有参数时，每次生成的随机数是一样的，同时选择不同的参数生成的随机数也不一样

3.numpy中的random.choice()函数

random.choice()函数：从给定的1维数组中随机采样的函数。

numpy.random.choice(a, size=None, replace=True, p=None)

a : 如果是一维数组，就表示从这个一维数组中随机采样；如果是int型，就表示从0到a-1这个序列中随机采样。
size : 采样结果的数量，默认为1.可以是整数，表示要采样的数量；也可以为tuple，如(m, n, k)，则要采样的数量为m * n * k，size为(m, n, k)。
replace : boolean型。replace=True是放回采样，False则为非放回采样
p : 一个一维数组，与数组a相对应，表示取数组a中每个元素的概率，默认为选取每个元素的概率相同。

官方解释：https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.choice.html

举例

#产生随机数
>>>np.random.choice(5)#从[0, 5)中随机输出一个随机数
#相当于np.random.randint(0, 5)
	2

>>>np.random.choice(5, 3)#在[0, 5)内输出五个数字并组成一维数组（ndarray）
#相当于np.random.randint(0, 5, 3)
	array([1, 4, 1])

#从数组，元组 列表中随机抽取
L = [1, 2, 3, 4, 5]#list列表
T = (2, 4, 6, 2)#tuple元组
A = np.array([4, 2, 1])#numpy,array数组,必须是一维的
A0 = np.arange(10).reshape(2, 5)#二维数组会报错

>>>np.random.choice(L, 5)
	array([3, 5, 2, 1, 5])
	
>>>np.random.choice(T, 5)
	array([2, 2, 2, 4, 2])
 
>>>np.random.choice(A, 5)
	array([1, 4, 2, 2, 1])

>>>np.random.choice(A0, 5)#如果是二维数组，会报错
	ValueError: 'a' must be 1-dimensional

#参数replace
np.random.choice(5, 6, replace=True)#可以看到有相同元素
	array([3, 4, 1, 1, 0, 3])
np.random.choice(5, 6, replace=False)#会报错，因为五个数字中取六个，不可能不取到重复的数字
	ValueError: Cannot take a larger sample than population when 'replace=False'

#参数p
>>> aa_milne_arr = ['pooh', 'rabbit', 'piglet', 'Christopher']
>>> np.random.choice(aa_milne_arr, 5, p=[0.5, 0.1, 0.1, 0.3])
	array(['pooh', 'pooh', 'pooh', 'Christopher', 'piglet'], dtype='|S11')
#可以看到，‘pooh’被选取的概率明显比其他几个高很多

4.np.asfarray的用法

参考:https://blog.csdn.net/qq_36501722/article/details/87829743

import numpy as np
a=np.array([["8",'1'],['3','7']])
print(a)
结果 ：
[['8' '1']
 ['3' '7']]
 

c=['1','2','3','4','5']
c=np.asfarray(c)
print(c)
结果： [1. 2. 3. 4. 5.]
 
 
 
d =["1","2\t","3\n","4"]
d=np.asfarray(d)
print(d)
 [1. 2. 3. 4.]
#注：asfarrary不仅可以对多维数组做数值处理，还可以对列表做去 转移符处理
#asfarray= as float array（不一定）

5.sorted(x,reverse=True)

reverse参数为True意味着按照降序排序，字符串是按照字符ascii值排序的并且第一个字符 相同时就会比较下一个字符的ascii值，以此类推

l = ['ac', 'bd', 'A', 'B', 'abc', 'bc']
print(sorted(l, reverse=True))
结果为['bd', 'bc', 'ac', 'abc', 'B', 'A']

6.np.random.permutation()

np.random.permutation()：随机排列序列。

import numpy as np
a=np.random.permutation(5)
print(a)
>>[0 3 2 4 1]

#对一个list随机排序
b=np.random.permutation([1,2,3,4,5])
print(b)
>>[5 2 3 4 1]

#矩阵多维度随机排序
c= np.arange(9).reshape((3,3))
print(c)
[[0 1 2]
 [3 4 5]
 [6 7 8]]
d=np.random.permutation(c)
[[3 4 5]
 [0 1 2]
 [6 7 8]]
#由此可见多维随机排序只在第一维上进行了随机排序

7.python argparse模块学习笔记

参考：https://blog.csdn.net/explorer9607/article/details/82623591?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task

8.lambda

lambda是个匿名函数，这个函数的参数就是(k,v),实际就是个元组，并且只有2个元素，返回值就是

(v,k)，即交换元组中两个元素的位置

f=lambda (k,v):(v,k)
>>> f((1,2))
(2, 1)

9. Python time clock()方法

Python time clock() 函数以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。

这个需要注意，在不同的系统上含义不同。在UNIX系统上，它返回的是"进程时间"，它是用秒表示的浮点数（时间戳）。而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时间。（实际上是以WIN32上QueryPerformanceCounter()为基础，它比毫秒表示更为精确）

语法：

time.clock()

10.sorted() 函数

sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

 

sorted(iterable, key=None, reverse=False)

返回值

返回重新排序的列表。

>>>sorted([5, 2, 3, 1, 4]) 
[1, 2, 3, 4, 5] # 默认为升序

你也可以使用 list 的 list.sort() 方法。这个方法会修改原始的 list（返回值为None）。通常这个方法不如sorted()方便-如果你不需要原始的 list，list.sort()方法效率会稍微高一些。

>>>a=[5,2,3,1,4] 
>>> a.sort()
>>> a 
[1,2,3,4,5]

另一个区别在于list.sort() 方法只为 list 定义。而 sorted() 函数可以接收任何的 iterable。

>>>sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}) 
[1, 2, 3, 4, 5]

利用key进行倒序排序

>>>example_list = [5, 0, 6, 1, 2, 7, 3, 4] 
>>> result_list = sorted(example_list, key=lambda x: x*-1) 
>>> print(result_list) 
[7, 6, 5, 4, 3, 2, 1, 0] 

要进行反向排序，也通过传入第三个参数 reverse=True：

>>>example_list = [5, 0, 6, 1, 2, 7, 3, 4] 
>>> sorted(example_list, reverse=True) 
[7, 6, 5, 4, 3, 2, 1, 0]

array = [{"age":20,"name":"a"},{"age":25,"name":"b"},{"age":10,"name":"c"}]
array = sorted(array,key=lambda x:x["age"])
print(array)
#输出结果：

[{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]

d1 = [{'name':'alice', 'score':38}, {'name':'bob', 'score':18}, {'name':'darl', 'score':28}, {'name':'christ', 'score':28}]
l = sorted(d1, key=lambda x:(-x['score'], x['name']))
print(l)
#输出结果：

[{'name': 'alice', 'score': 38}, {'name': 'christ', 'score': 28}, {'name': 'darl', 'score': 28}, {'name': 'bob', 'score': 18}]

python中map（）函数进行数据转换

用法：
map(function, iterable, …),
返回的是map型，（ps：python2中返回的是list型可以直接显示，但在python3中是map型无法直接显示）
参数function： 传的是一个函数名，可以是python内置的，也可以是自定义的。
参数iterable ：传的是一个可以迭代的对象，例如列表，元组，字符串这样的
功能：将iterable中的每一个元素执行一遍function

map类型无法直接显示，需要list（）函数.

例如(list(map(int, line.split(','))))

line.split(',')表示把line字符串按照逗号切分成多个字符串存在一个列表中

map(float,line.split(','))表示把切分出的列表的每个值,用float函数把它们转成float型,并返回迭代器

list(map(float,line.split(',')))表示用list函数把map函数返回的迭代器遍历展开成一个列表

我给你一个Python语言的例子,你看看吧

line='123,456,789'

print(list(map(float,line.split(','))))

输出[123.0,456.0,789.0]

python 字典defaultdict(list)

https://blog.csdn.net/weixin_38145317/article/details/93175217

from collections import defaultdict
result = defaultdict(list)
data = [("p", 1), ("p", 2), ("p", 3),
        ("h", 1), ("h", 2), ("h", 3)]
 
for (key, value) in data:
    result[key].append(value)
print(result)
#defaultdict(<class 'list'>, {'p': [1, 2, 3], 'h': [1, 2, 3]})

pd.Series()函数

Pandas模块的数据结构主要有两种：1.Series 2.DataFrame
Series 是一维数组，基于Numpy的ndarray 结构

pd.Series([list],index=[list])
参数为list ,index为可选参数，若不填写则默认为index从0开始

https://blog.csdn.net/weixin_43868107/article/details/102631717

import Pandas as pd 
import numpy as np

obj = pd.Series([4, 7, -5, 3, 7, np.nan])
obj

#输出结果
0    4.0
1    7.0
2   -5.0
3    3.0
4    7.0
5    NaN
dtype: float64

arr = np.arange(6)
s = pd.Series(arr)
s
0    0
1    1
2    2
3    3
4    4
5    5
dtype: int32


d = {'a':10,'b':20,'c':30,'d':40,'e':50}
s = pd.Series(d)
s
a    10
b    20
c    30
d    40
e    50
dtype: int64

set()

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

>>>x = set('runoob')
>>> y = set('google')
>>> x, y
(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除
>>> x & y         # 交集
set(['o'])
>>> x | y         # 并集
set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
>>> x - y         # 差集
set(['r', 'b', 'u', 'n'])
>>>

np.full()

np.full 构造一个数组，用指定值填充其元素

full(shape, fill_value, dtype=None, order='C')

• shape：int 或者 int元组

fill_value：填充到数组中的值

import numpy as np
 
# 构造一个2x3的数组，其中元素全部都为 7
ndarray = np.full((2, 3), 7)
print(ndarray)
"""
[[7 7 7]
 [7 7 7]]
"""

heapq模块中的两个函数——nlargest()和nsmallest()

这两个函数可以帮助我们在某个集合中找出最大或最小的N个元素。例如：

>>> import heapq
>>> nums=[1,8,2,23,7,-4,18,23,42,37,2]
>>> print(heapq.nlargest(3,nums))
[42, 37, 23]
>>> print(heapq.nsmallest(3,nums))
[-4, 1, 2]