常用python函数的语法

最新推荐文章于 2023-03-31 11:08:48 发布

1051450906

最新推荐文章于 2023-03-31 11:08:48 发布

阅读量452

点赞数 3

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/qq_38162944/article/details/113392499

版权

Python 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

pycharm

撤销快捷键 Ctrl+z
注释快捷键 Ctrl+/

split()函数
append()
pow（x，y）
np.concatenate函数
np.reshape()函数来对矩阵设定所需的维度。
np.mean()函数
np.ptp( ) 函数
numpy.insert（）函数
numpy.dot() 和 x.dot(y) 为矩阵乘法计算
python中的“.T”操作
numpy矩阵中向量问题
len()函数
np.arange()用法
numpy.std() ,pandas.std()计算矩阵标准差
np.zip()
enumerate()在遍历中可以获得索引和元素值。

split()函数

Python split()通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串

    split()方法语法：str.split(str=" ", num=string.count(str)).
    #str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
    #num -- 分割次数。

    >>>ipaddr = "10.122.19.101 "
    >>>print(ipaddr.split('.'))
    
      ['10', '122', '19', '101 ']


    >>>ipaddr = "10.122.19.101  nn "
    >>>print(ipaddr.split(' ',1))
    
 	['10.122.19.101', ' nn ']

append()

此方法用于在列表末尾添加新的对象。

append()方法语法：list.append(obj)      
#obj – 添加到列表末尾的对象。
#该方法无返回值，但是会修改原来的列表

>>>c= [1, 2, 3]
>>>d = 4
>>>y = c.append(d)
>>>print(y)
>>>print(c)

None

[1, 2, 3, 4]

pow（x，y）

二元形式pow（x，y）等效于使用幂运算符：x ** y。
三元形式pow（x，y，z),则将x ** y，取余z。它的计算比使用pow（x，y）％z更有效。

>>>print(pow(10, 2))
>>>print(pow(-10, 3))
>>>print(pow(10, 2, 3))

100
-1000
1

np.concatenate函数

>>> a = np.array([[1, 2], [3, 4]])
>>> b = np.array([[5, 6], [7, 8]])
>>> np.concatenate((a,b),axis=0)
     
      [[1, 2],
       [3, 4],
       [5, 6],
       [7, 8]]
       
>>> a = np.array([[1, 2], [3, 4]])
>>> b = np.array([[5, 6], [7, 8]])
>>> np.concatenate((a,b),axis=1)
     
      [[1, 2, 5, 6],
       [3, 4, 7, 8]]

>>> c = np.concatenate((a,b),axis=1)
>>> c
      [[1, 2, 5, 6],
       [3, 4, 7, 8]])
       
>>> c.shape
(2, 4)

np.reshape()函数来对矩阵设定所需的维度。

np.reshape(-1)、np.reshape(-1, 1)、np.reshape(1, -1)详解

np.reshape(-1)

>>>original = np.array([2, 4, 1, 3],[1, 2, 5, 2])
>>>orginal.shape 
(2, 4)

>>>new_1 = orginal.reshape(-1)
>>>print(new_1) 

[2, 4, 1, 3, 1, 2, 5, 2]

np.reshape(-1, 1)

>>>original = np.array([2, 4, 1, 3],[1, 2, 5, 2])
# 设定新排布的列数为1，行数为未知
>>>new_2 = orginal.reshape(-1, 1)
>>>print(new_2)  # 新排布为（8，1）

       [[ 2],
		[ 4],
		[ 1],
		[ 3],
		[ 1],
		[ 2], 
		[ 5],
		[ 2]]

np.reshape(1, -1)

>>>original = np.array([2, 4, 1, 3],[1, 2, 5, 2])
# 设定新排布的行数为1，列数为未知
>>>new_3 = orginal.reshape(1, -1)
>>>print(new_3)  # 新排布为（1，8）

[2, 4, 1, 3, 1, 2, 5, 2]

np.reshape(-1, 2)

>>>original = np.array([2, 4, 1, 3],[1, 2, 5, 2])
# 设定新排布的列数为2，行数为未知
>>>new_4 = original.reshape(-1, 2)
>>>print(new_4) # 新排布为（4，2）

[[2, 4],
 [1, 3],
 [1, 2],
 [5, 2]]

np.mean()函数

在这里插入图片描述


>>>a = np.array([[1, 2], [3, 4]])
>>>print(a)
>>>print(type(a))
>>>print(np.mean(a))
>>>print(np.mean(a, axis=0)) # axis=0，计算每一列的均值
>>>print(np.mean(a, axis=1)) # 计算每一行的均值

[[1 2]
 [3 4]]
<class 'numpy.ndarray'>
2.5
[2. 3.]
[1.5 3.5]

np.ptp( ) 函数

>>>a = np.arange(9).reshape((3,3))
>>>print(a)

[[0 1 2]
 [3 4 5]
 [6 7 8]]
 



>>>b = np.ptp(a, axis=0)  # axis=0 表示纵向
>>>print(b) # [6 6 6]  # 6-0, 7-1, 8-2
 
 6
>>>c = np.ptp(a, axis=1)  # axis=1 表示横向
>>>print(c) # [2 2 2]  # 2-0, 5-3, 8-6
2

numpy.insert（）函数

a = np.arange(12).reshape((3, 4))
print(a)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

print(np.insert(a, 2, 100))
# [  0   1 100   2   3   4   5   6   7   8   9  10  11]

b1 = np.arange(100, 104)
print(b1)
# [100 101 102 103]

print(np.insert(a, 1, b1, axis=0))
# [[  0   1   2   3]
#  [100 101 102 103]
#  [  4   5   6   7]
#  [  8   9  10  11]]

print(np.insert(a, 3, b1, axis=0))
# [[  0   1   2   3]
#  [  4   5   6   7]
#  [  8   9  10  11]
#  [100 101 102 103]]

print(np.insert(a, [0, 2], b1, axis=0))
# [[100 101 102 103]
#  [  0   1   2   3]
#  [  4   5   6   7]
#  [100 101 102 103]
#  [  8   9  10  11]]

print(a)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

print(np.insert(a, 1, 100, axis=1))
# [[  0 100   1   2   3]
#  [  4 100   5   6   7]
#  [  8 100   9  10  11]]

c1 = np.arange(100, 103)
print(c1)
# [100 101 102]

print(np.insert(a, 1, c1, axis=1))
# [[  0 100   1   2   3]
#  [  4 101   5   6   7]
#  [  8 102   9  10  11]]

print(np.insert(a, 3, c1, axis=1))
# [[  0   1   2 100   3]
#  [  4   5   6 101   7]
#  [  8   9  10 102  11]]

>>>a = np.array([[1, 2], [3, 4]])
>>>print(a.ndim)
>>>print(a.shape)
>>>print(a.size)

2
(2,2)
4

numpy.dot() 和 x.dot(y) 为矩阵乘法计算

>>>import numpy as np

>>>mat1 = np.array([[1, 2, 3], 
                 [4, 5, 6]])
>>>mat2 = np.array([[1, 2],
                 [1, 2],
                 [1, 2]])
>>>np.dot(mat1, mat2)         # numpy.dot()

array([[ 6, 12],
       [15, 30]])


>>>mat1.dot(mat2)             # x.dot(y)

array([[ 6, 12],
       [15, 30]])

python中的“.T”操作

其实就是对一个矩阵的转置

>>>a=array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
>>>a.T

array([[1, 4, 7],
       [2, 5, 8],
       [3, 6, 9]])

numpy中默认的一维数组形式可能是
x = np.array([1,2,3,4])
此时对此数组进行转置操作 x.T 没用，因为转置操作只能用在二维数组上
要对其变为列向量，采用以下操作
x = np.array([x])
此时变为array([[1, 2, 3, 4]]) 二维数组，然后转置

numpy矩阵中向量问题

>>>a = np.random.randn(5)
>>>print(a.shape)
>>>print(a)
>>>>print(a.T)
>>>print(np.dot(a,a.T))
(5,)
[-0.22092417 -1.82908627  0.12921913  0.08761382 -1.16835714]
[-0.22092417 -1.82908627  0.12921913  0.08761382 -1.16835714]
4.783796239215634
这条np.random.randn(5)语句生成的a的维度是（5，）。
它既不是行向量也不是列向量，我们把a叫做秩为1的矩阵。
这种定义会带来一些问题。例如我们对a进行转置，还是会得到a本身。
但是矩阵a点乘a.T确是一个数字！！！(相当于一行向量乘一列向量)
所以，如果我们要定义（5，1）的列向量或者（1，5）的行向量，最好使用下来标准语句，避免使用rank 1 array。

>>>a = np.random.randn(1,5)
>>>print(a)
[[-0.41519529 -0.80304889 -0.4526664   2.28050683  1.02830914]]#二维数组的（1,5）,注意看[[]
 
>>>b = np.random.randn(5,1)
>>>print(b)
[[ 0.74035135]#二维数组的（5,1）注意看[[]]
 [-0.68593586]
 [ 0.03862474]
 [ 1.06032259]
 [ 0.44886708]]

>>>print(np.dot(a,b))#二维数组的（1,1）注意看[[]]
[[3.10561253]]

len()函数

>>>import numpy as np
>>>X1=np.array([[1,2,3,4],
                [5,6,7,8],
                [9,10,11,12]])
 
>>>length1=len(X1)  #返回对象的长度   不是元素的个数,可以想象成数据长度/条数，即数据的行数
>>>print("length of X1:",length1)
 
length of X1: 3

>>>X2 = np.array([1, 2, 3, 4])
>>>length2=len(X2)  #返回对象的长度   不是元素的个数,可以想象成数据长度/条数
>>>print("length of X2:",length2)

length of X2: 4

np.arange()用法

#一个参数 默认起点0，步长为1 输出：[0 1 2]
a = np.arange(3)

#两个参数 默认步长为1 输出[3 4 5 6 7 8]
a = np.arange(3,9)

#三个参数 起点为0，终点为3，步长为0.1 输出
#[ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9  1.   1.1  1.2  1.3  1.4 1.5  1.6  1.7  1.8  1.9  2.   2.1  2.2  2.3  2.4  2.5  2.6  2.7  2.8  2.9]
a = np.arange(0, 3, 0.1)

numpy.std() ,pandas.std()计算矩阵标准差

计算得出的默认标准偏差类型在 numpy 的 .std() 和 pandas 的 .std() 函数之间是不同的。
默认情况下，numpy 计算的是总体标准偏差，ddof = 0。
另一方面，pandas 计算的是样本标准偏差，ddof = 1。
如果我们知道所有的分数，那么我们就有了总体
因此，要使用 pandas 进行归一化处理，我们需要将“ddof”设置为 0。


numpy.std() 求标准差的时候默认ddof = 0是除以 n 的，即是有偏的，
numpy.std无偏样本标准差方式为加入参数 ddof = 1；
pandas.std() 默认ddof = 1是除以n-1 的，即是无偏的，
如果想有偏，需要加上参数ddof=0 ，即pandas.std(ddof=0) 


>>> a = np.array([[1, 2], [3, 4]])
>>> np.std(a) # 计算全局标准差
1.1180339887498949

>>> np.std(a, axis=0) # axis=0计算每一列的标准差
array([ 1.,  1.])

>>> np.std(a, axis=1) # 计算每一行的标准差
array([ 0.5,  0.5])

np.zip()

uppercase = ['A', 'B', 'C']
lowercase = ['a', 'b', 'c']
for x, y in zip(uppercase, lowercase):
    print(x, y)
    
>>> 以下是输出结果

A a
B b
C c


b = ["red", "green", "blue"]
c = ["leopard", "cheetah", "jaguar"]

print(list(zip(b, c)))

>>>
将zip()对象转换为列表

[('red', 'leopard'), ('green', 'cheetah'), ('blue', 'jaguar')]

b = ["red", "green", "blue"]
f = ["strawberry", "kiwi", "blueberry"]

print(dict(zip(b, f)))

>>>
将zip()对象转换成字典
{'red': 'strawberry', 'green': 'kiwi', 'blue': 'blueberry'}

enumerate()在遍历中可以获得索引和元素值。

普通的for循环如下：
>>>list = ["Python","Java","C"]
>>>for i in range(len(list)):
>>>    print(i,list[i])

0 Python
1 Java
2 C


而使用enumerate()函数可以这样写，如下：
>>>list = ["Python","Java","C"]

>>>for index,key in enumerate(list):
>>>    print(index,key)

0 Python
1 Java
2 C

此外，enumerate()函数还有第二个参数，用于指定索引的起始值，如下：
>>>list = ["Python","Java","C"]
>>>for index,key in enumerate(list,start=10):
>>>    print(index,key)

10 Python
11 Java
12 C