碼上歡樂
相關內容    簡體    繁體

python常用函數及模塊

本文轉載自   查看原文   2018-06-18 13:30   1168    python/ 自動化測試/ python常用函數/ 軟件測試/ python常用函數總結

原文來源於博客園和CSDN

1.計算函數

abs（）--取絕對值

max()--取序列最大值，包括列表、元組

min（）--取序列最小值

len()--取長度

divmod（a,b）---取a//b除數整數以及余數，成為一個元組

pow（x,y）--取x的Y次冪

pow（x,y，z）先x的Y次冪，再對Z取余

round（）--修改精度，如果沒有，默認取0位

range（）快速生成一個列表

2.其他函數

callable（）--返回是否可調用返回true或false

isinstance（a,type）---判斷前面的是否是后面的這種類型，返回true或false

cmp（a,b）---判斷ab是否相等，相等返回0，A<B返回-1，A>B返回1

range（）--快速生成一個列表,類型為list

xrange()---快速生成一個列表，類型為xrange

3.類型轉換函數

type（）

int（）

long（）

float（）

complex（）--轉換成負數

hex（）--轉換成十六進制

oct（）--轉換成八進制

chr（）--參數0-252，返回當前的ASCII碼

ord（）--參數ASCII碼，返回對應的十進制整數

4.string函數

str.capitalize()--對字符串首字母大寫

str.replace(a.b)---對字符串a改為b

str.split()---對字符串進行分割,第一個參數是分隔符，后面參數是分割幾次。

string函數導入使用

5.序列函數

filter（）--篩選返回為true返回成序列

lambda--定義函數

zip（）---對多個列表進行壓縮組合成一個新列表，但是如果多個列表的元素個數不同，組合的結果按最少元素的進行組合

map--對多個列表進行壓縮組合成一個新列表，但是如果多個列表的元素個數不同，結果是將所有的元素取出來，缺少的以None代替。如果是None，直接組合，如果是函數，可以按函數進行組合

reduce()--對每個元素先前兩個執行函數，然后結果和后一個元素進行函數操作，如階乘，階加

 

-----------------------------------------------------------------------------------------------------------------------

-----------------------------------------------------------------------------------------------------------------------

urlencode與urldecode

當url中包含中文或者參數包含中文，需要對中文或者特殊字符（/、&）做編碼轉換。
urlencode的本質：把字符串轉為gbk編碼，再把\x替換成%。如果終端是utf8編碼的，需要把結果再轉成utf8輸出，否則會亂碼。

urlencode

urllib庫里面的urlencode函數，可以把key-value健值對的key、value都進行urlencode並轉換成a=1&b=2的字符串。

#key-value健值對 >>> from urllib import urlencode >>> data={'a':'a1','b':'中文'} >>> print urlencode(data) a=a1&b=%E4%B8%AD%E6%96%87 >>> data={'a':'a1','b測試':'中文'} >>> print urlencode(data) a=a1&b%E6%B5%8B%E8%AF%95=%E4%B8%AD%E6%96%87

urllib庫里面的quote函數，可以針對單個字符串進行urlencode轉換。

#string >>> from urllib import quote >>> data="測試" >>> print quote(data) %E6%B5%8B%E8%AF%95

urldecode

urllib只提供了unquote()函數。

>>> from urllib import unquote
>>> unquote("%E6%B5%8B%E8%AF%95") '\xe6\xb5\x8b\xe8\xaf\x95' >>> print unquote("%E6%B5%8B%E8%AF%95") 測試 >>>

json處理

兩個函數：

函數 描述
json.dumps 將python對象編碼成JSON字符串（對象->字符串）
json.loads 將已經編碼的json字符串解碼為Python對象（字符串->對象）

json.dumps

語法：json.dumps(data, sort_keys=True, indent=4,separators=(self.item_separator, self.key_separator))

>>> import json >>> data={"a":"a1","b":"b1"} >>> jsonstr=json.dumps(data) >>> print jsonstr {"a": "a1", "b": "b1"} #輸出格式化 >>> print json.dumps(data, sort_keys=True, indent=4,separators=(",",":")) { "a":"a1", "b":"b1" } >>>

python原始類型向json類型的轉換對照表：

Python JSON
dict object
list，tuple array
str,unicode string
int,long,float number
True true
False false
None null

json.loads

json.loads——返回Python字段的數據類型

>>> import json >>> jsonstr='{"a":"a1","b":"b1"}' >>> print json.loads(jsonstr) {u'a': u'a1', u'b': u'b1'} >>> jsonstr='{"a":"a1","b":null,"c":false,"d":{"aa":"aa1","bb":"bb1"}}' >>> print json.loads(jsonstr) {u'a': u'a1', u'c': False, u'b': None, u'd': {u'aa': u'aa1', u'bb': u'bb1'}} >>> jsonstr='[{"a":"a1"},{"b":"b2"}]' >>> print json.loads(jsonstr) [{u'a': u'a1'}, {u'b': u'b2'}]

json類型轉換為python類型的對照表

JSON Python
object dict
array list
string unicode
number(int) int,long
number(real) float
true True
false False
null None

結論：print只能輸出python認識的數據類型，python.dumps才可以格式化輸出。

計算字符串md5

方法一：使用md5包

import md5
def calMd5(signdata,signkey,joiner=""):
    signdata=signdata+joiner+""+signkey
    m=md5.new(signdata)
    sign = m.hexdigest()
    return sign

 

方法二：使用hashlib包

import hashlib
def calHashMd5(signdata,signkey,joiner=""):
    signdata=signdata+joiner+""+signkey
    m=hashlib.md5(signdata)
    sign = m.hexdigest()
    return sign

 

計算hmacsha1

hmac:密鑰相關的哈希運算消息認證碼，hmac運算利用哈希算法（可以是MD5或者SHA-1），以一個密鑰和一個消息為輸入，生成一個消息摘要作為輸出。

作用：
（1）驗證接受的授權數據和認證數據；
（2）確認接受到的命令請求是已經授權的請求且傳送過程沒有被篡改

import hmac
import base64
def hmacSha1WithBase64(signdata,signkey):
    sign = hmac.new(signkey, signdata,sha1).digest()
    sign = base64.b64encode(sign)
    return sign

 

字符串拼接

from collections import OrderedDict

def composeStr(data,joiner,withkey=True,key_value_joiner="="):
    data = OrderedDict(sorted(data.items(), key=lambda t:t[0]))
    if withkey :
        signdata = joiner.join([key_value_joiner.join((str(key), str(elem))) for key, elem in data.iteritems()])
    else :
        signdata= joiner.join([elem for key, elem in data.items()])
    return signdata

 

 

-----------------------------------------------------------------------------------------------------------------------

-----------------------------------------------------------------------------------------------------------------------

python常見函數

abs函數

abs函數用來求一個數的絕對值

abs(-1.24)

max函數

max函數用來求多個參數的最大值

max(2,3,1,-5)

類型轉換函數

常見的類型轉換函數，包括int(),float(),bool(),str()等

str(100)

hex函數

hex函數可以將一個整數轉換為十六進制表示的字符串

hex(255)

可以改變函數名字

#將a指向abs函數 a = abs a(-1)

空函數

定義一個什么都不做的函數：

def nop(): pass

空函數的作用：pass作為占位符，能夠先讓代碼運行起來，還可以用作其他語句中：

if age >= 18: pass

這里pass不能缺少，不然語法錯誤。

參數檢查

數據類型檢查可以用內置函數isinstance()來實現:

def my_abs(x):
    if not isinstance(x, (int,float)):
            raise TypeError('bad operand type')
    if x >= 0:
        return x
    else :
        return -x

 

添加完之后如果輸入錯誤的參數類型就會拋出你指定的錯誤

函數多返回值

導入包使用import語句

import math

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx,ny

x,y = move(100, 100, 60, math.pi / 6)
print(x,y)

 

其實他的返回值依然是一個值來的，不過因為這個返回值是tuple類型而已。

# 求一元二次方程解
def quadratic(a, b, c):
    if not isinstance(a, (int,float)) and isinstance(b, (int, float)) and isinstance(c, (int, float)):
        raise TypeError('bad operand type')

    if a == 0:
        return 'a不能為0'

    n = float(b * b - 4 * a *c)

    if n < 0:
        return '方程無解'
    elif n == 0:
        x = int(-b / (2 * a))
        return '方程的解為：x = %lf' % x
    else:
        x1 = (-b + math.sqrt(n)) / (2 * a)
        x2 = (-b - math.sqrt(n)) / (2 * a)
        return '方程的解為：x1 = %.1f,x2 = %.1f'%(x1,x2)

a = float(input('請輸入a:'))
b = float(input('請輸入b:'))
c = float(input('請輸入c:'))
print(quadratic(a, b, c))

 




-----------------------------------------------------------------------------------------------------------------------

-----------------------------------------------------------------------------------------------------------------------



#字母的數字的相互轉換

 

[python]  view plain  copy
 
  1. #ord:字母轉數字  
  2. ord('A')  
  3. #chr:數字轉字母  
  4. chr(65)  
 

#python 的三元表達式的用法

 

[python]  view plain  copy
 
  1. #給定數字1或0 轉為是與否  
  2. k = '1'  
  3. d = '是' if int(k) else '否'  

 

#python lambda表達式

lambda表達式可以很方便的用來代替簡單函數

 

[python]  view plain  copy
 
  1. #float轉str 去掉末尾的'.0'  
  2. >>> func = lambda x:str(x) if int(str(x).split('.')[1]) else str(x).split('.')[0]  
  3. >>> func(2.0)  

相當於

 

[python]  view plain  copy
 
  1. def func(x):  
  2.     if int(str(x).split('.')[1]):  
  3.         x = str(x)  
  4.     else:  
  5.         x = str(x).split('.')[0]  
  6.     return x  
  7. print (func(2.0))  
 
#python 列表推導式

 

[python]  view plain  copy
 
  1. #二維元組轉列表  
  2. a = (  
  3.     ('魏登武', 18912347226.0, '農商行',0.0, 4.0, 0.0, 11820.0, 0.0, 0.0, 11560.0, 0.0,  '0', '0.08', '70', '0', '張明鋒'),  
  4.     ('魏德華', 18712345620.0, None,0.0, 3.0, 10000.0, 5000.0, 4000.0, 0.0, 0.0, 0.0,  None, '0.05', '70', '1', '賀世海')  
  5.     )  
  6. b = [list(i) for i in a]  
  7. print (b)  

#列表推導式嵌套

 

[python]  view plain  copy
 
  1. #二維元組轉列表  
  2. #win32com操作excel--->sheet.Range().value得到 a 這樣的元組  
  3. #sheet.Range(sheet.Cells(row1, col1), sheet.Cells(row2, col2)).Value     
  4. a = (  
  5.     ('魏登武', 18912347226.0, '農商行',0.0, 4.0, 0.0, 11820.0, 0.0, 0.0, 11560.0, 0.0,  '0', '0.08', '70', '0', '張世鋒'),  
  6.     ('魏德華', 18712345620.0, None,0.0, 3.0, 10000.0, 5000.0, 4000.0, 0.0, 0.0, 0.0,  None, '0.05', '70', '1', '賀明海')  
  7.     )  
  8. b = [list(i) for i in a]#元組轉列表  
  9.   
  10. def func(i):  
  11.     if i == None:  
  12.         i = ''  
  13.     elif type(i) == float:  
  14.         i = str(i).split('.')[0] if str(i).split('.')[1] == '0' else str(i)  
  15.     return i  
  16. #列表推導式嵌套  
  17. c = [[func(j) for j in i] for i in b]#替換二維列表里的None和float轉str並去掉小數為0 的  ‘.0’  
  18. print (c)  

 

 

 

#ord:字母轉數字

ord('A')

 #chr:數字轉字母

chr(65)

 

 
#json與列表的相互轉換
dumps#
json.dumps(k)->json


k = '123'
json.loads(k)->列表


#正確獲取當前的路徑：
print (os.path.dirname(os.path.realpath(__file__)))
 

-----------------------------------------------------------------------------------------------------------------------

-----------------------------------------------------------------------------------------------------------------------

內置函數，一般都是因為使用比較頻繁或是元操作，所以通過內置函數的形式提供出來。在Python中，python給我們提供了很多已經定義好的函數，這里列出常用的內置函數，分享出來供大家參考學習，下面話不多說，來一起看看詳細的介紹吧。

一、數學函數

  • abs() 求數值的絕對值
  • min()列表的最下值
  • max()列表的最大值
  • divmod() 取膜
  • pow() 乘方
  • round()浮點數
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#abs 絕對值函數 輸出結果是1
 
print abs ( - 1 )
 
#min 求列表最小值
#隨機一個1-20的步長為2的列表
lists = range ( 1 , 20 , 2 )
 
#求出列表的最小值為1
print min (lists)
 
#max 求列表的最大值 結果為19
 
print max (lists)
 
#divmod(x,y) 參數：2個 返回值：元祖
#函數計算公式為 ((x-x%y)/y, x%y)
print divmod ( 2 , 4 )
 
#pow(x,y,z)
#參數：2個或者3個 z可以為空
# 計算規則 (x**y) % z
print pow ( 2 , 3 , 2 )
 
#round(x)
#將傳入的整數變稱浮點
print round ( 2 )

二、功能函數

  • 函數是否可調用：callable(funcname)
  • 類型判斷：isinstance(x,list/int)
  • 比較：cmp(‘hello','hello')
  • 快速生成序列： (x)range([start,] stop[, step])
  • 類型判斷 type()
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#callable（）判斷函數是否可用 返回True ,這里的函數必須是定義過的
 
def getname():
  print "name"
 
print callable (getname)
 
 
#isinstance(object, classinfo)
# 判斷實例是否是這個類或者object是變量
a = [ 1 , 3 , 4 ]
print isinstance (a, int )
 
#range（[start,] stop[, step]）快速生成列表
# 參數一和參數三可選 分別代表開始數字和布長
#返回一個2-10 布長為2的列表
print range ( 2 , 10 , 2 )
 
#type(object) 類型判斷
 
print type (lists)

三、類型轉換函數

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#int(x)轉換為int類型
 
print int ( 2.0 )
#返回結果<type 'int'>
print type ( int ( 2.0 ))
 
#long(x) 轉換稱長整形
print long ( 10.0 )
#float(x) 轉稱浮點型
print float ( 2 )
#str(x)轉換稱字符串
print str ()
#list(x)轉稱list
print list ( "123" )
#tuple(x)轉成元祖
print tuple ( "123" )
#hex(x)
print hex ( 10 )
#oct(x)
print oct ( 10 )
#chr(x)
print chr ( 65 )
#ord(x)
print ord ( 'A' )

四、字符串處理

?
1
2
3
4
5
6
7
8
9
10
11
12
13
name = "zhang,wang"
 
#capitalize首字母大寫
#Zhang,wang
print name.capitalize()
 
#replace 字符串替換
#li,wang
print name.replace( "zhang" , "li" )
 
#split 字符串分割 參數：分割規則，返回結果：列表
#['zhang', 'wang']
print name.split( "," )

五、序列處理函數

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
strvalue = "123456"
a = [ 1 , 2 , 3 ]
b = [ 4 , 5 , 6 ]
 
#len 返回序列的元素的長度6
print len (strvalue)
 
#min 返回序列的元素的最小值1
 
print min (strvalue)
 
#max 返回序列元素的最大值6
print max (strvalue)
 
#filter 根據特定規則，對序列進行過濾
#參數一：函數 參數二：序列
#[2]
def filternum(x):
  if x % 2 = = 0 :
   return True
print filter (filternum,a)
 
 
 
#map 根據特定規則，對序列每個元素進行操作並返回列表
#[3, 4, 5]
def maps(x):
  return x + 2
print map (maps,a)
 
 
#reduce 根據特定規則，對列表進行特定操作，並返回一個數值
#6
def reduces(x,y):
  return x + y
print reduce (reduces,a)
 
#zip 並行遍歷
#注意這里是根據最序列長度最小的生成
#[('zhang', 12), ('wang', 33)]
name = [ "zhang" , "wang" ]
age = [ 12 , 33 , 45 ]
print zip (name,age)
 
 
#序列排序sorted 注意：返回新的數列並不修改之前的序列
print sorted (a,reverse = True )

 

 

 

-----------------------------------------------------------------------------------------------------------------------

-----------------------------------------------------------------------------------------------------------------------

一、數學相關

1、絕對值：abs(-1)
2、最大最小值：max([1,2,3])、min([1,2,3])
3、序列長度：len('abc')、len([1,2,3])、len((1,2,3))
4、取模：divmod(5,2)//(2,1)
5、乘方：pow(2,3,4)//2**3/4
6、浮點數：round(1)//1.0

二、功能相關

1、函數是否可調用：callable(funcname)，注意，funcname變量要定義過
2、類型判斷：isinstance(x,list/int)
3、比較：cmp('hello','hello')
4、快速生成序列：(x)range([start,] stop[, step])

三、類型轉換

1、int(x)
2、long(x)
3、float(x)
4、complex(x) //復數
5、str(x)
6、list(x)
7、tuple(x) //元組
8、hex(x)
9、oct(x)
10、chr(x)//返回x對應的字符，如chr(65)返回‘A'
11、ord(x)//返回字符對應的ASC碼數字編號，如ord('A')返回65

四、字符串處理

1、首字母大寫：str.capitalize

復制代碼代碼如下:

>>> 'hello'.capitalize()


'Hello'
2、字符串替換：str.replace

復制代碼代碼如下:

>>> 'hello'.replace('l','2')
'he22o'


可以傳三個參數，第三個參數為替換次數

 

3、字符串切割：str.split

復制代碼代碼如下:

>>> 'hello'.split('l')
['he', '', 'o']


可以傳二個參數，第二個參數為切割次數

 

以上三個方法都可以引入String模塊，然后用string.xxx的方式進行調用。

五、序列處理函數

1、len：序列長度
2、max：序列中最大值
3、min：最小值
4、filter：過濾序列

復制代碼代碼如下:

>>> filter(lambda x:x%2==0, [1,2,3,4,5,6])
[2, 4, 6]

 

5、zip：並行遍歷

復制代碼代碼如下:

>>> name=['jim','tom','lili']
>>> age=[20,30,40]
>>> tel=['133','156','189']
>>> zip(name,age,tel)
[('jim', 20, '133'), ('tom', 30, '156'), ('lili', 40, '189')]


注意，如果序列長度不同時，會是下面這樣的結果：

復制代碼代碼如下:

>>> name=['jim','tom','lili']
>>> age=[20,30,40]
>>> tel=['133','170']
>>> zip(name,age,tel)
[('jim', 20, '133'), ('tom', 30, '170')]


6、map：並行遍歷，可接受一個function類型的參數

復制代碼代碼如下:

>>> a=[1,3,5]
>>> b=[2,4,6]
>>> map(None,a,b)
[(1, 2), (3, 4), (5, 6)]
>>> map(lambda x,y:x*y,a,b)
[2, 12, 30]


7、reduce：歸並

復制代碼代碼如下:

>>> l=range(1,101)
>>> l
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> reduce(lambda x,y:x+y,l)
5050
 

-----------------------------------------------------------------------------------------------------------------------

-----------------------------------------------------------------------------------------------------------------------

列表

list1.append（x）         將x添加到列表末尾

list1.sort（）                對列表元素排序

list1.reverse（）            將列表元素逆序

list1.index（x）             返回第一次出現元素x的索引值

list1.insert（i，x）            在位置i處插入新元素x

list1.count（x）                返回元素x在列表中的數量

list1.remove（x）            刪除列表中第一次出現的元素x

list1.pop（i）                    取出列表中i位置上的元素，並將其刪除

 

元組

  1. 元組（tuple）是特殊的序列類型
  2. 一旦被創建就不能修改，使得代碼更安全
  3. 使用逗號和圓括號來表示，如（‘red’，‘blue’，‘green’），（2，4 , 6）
  4. 訪問方式和列表相同
  5. 一般用於表達固定數據項，函數多返回值等情況

特點：

  1. 元組中的元素可以是不同類型
  2. 元組中各元素存在先后關系，可通過索引訪問元組中的數據     

 

math庫

math.pi            圓周率

math.ceil（x）        對x向上取整

math.floor（x）        對x向下取整

math.pow（x，y）    x的y次方

math.sqrt（x）          x的平方根

math.fsum（list1）    對集合內的元素求和

更多math庫函數請參考：https：//docs.python.org/3/library/math.html

 

datetime庫

  • 處理時間的標准函數庫datetime
  • datetime.now()獲取當前日期和時間                            

 

  • 字符串->datetime

       datetime.strptime(),解析時間字符串  

        注釋：Y表示四位數年份，y表示兩位數年份。

 

  • datetime->字符串

        datetime.strftime()，格式化datetime為字符串顯示

 

  • 日期時間格式參考：

            https://docs.python.org/3/library/datetime.html#strftime-strptime-behavior

  • isocalendar()，返回年，周數，及周幾
  • 更多操作參考：

            https://docs.python.org/3/library/datetime.html#module-datetime

 

集合

  • python中的集合（set）類型同數學中的集合概念一致，即包含0或多個數據項的無序組合
  • 集合中的元素不可重復
  • 集合是無序組合，沒有索引和位置的概念
  • set（）函數用於集合的生成，返回結果是一個無重復且排序任意的集合
  • 集合通常用於表示成員間的關系、元素去重等。

集合的操作：

 

  • s-t 或 s.difference(t)        返回在集合s中但不在t中的元素
  • s&t 或 s.intersection(t)       返回同時在集合s和t中的元素
  • s|t 或 s.union(t)       返回結合s和t中的所有元素
  • s^t 或 s.symmetric_difference(t)        返回集合s和t中的元素，但不包括同時在其中的元素。

 

字典

  • 字典類型（dict）是‘’鍵--值‘’數據項的組合，每個元素是一個鍵值對。

        例如：身份證號（鍵）--個人信息（值）

 

  • 字典類型數據通過映射查找數據項
  • 映射：通過任意鍵查找集合中的值得過程
  • 字典類型以鍵為索引，一個鍵對應一個值
  • 字典類型的數據是無序的

基本操作：

 

  • 定義空字典：        d = dict（）

  • 增加一項：        d[key] = value

  • 訪問：        d[key]
  • 刪除某項：        del d[key]
  • key是否在字典中：        key in d
  • 字典的遍歷：

              遍歷所有的key：    for key in d.keys():

                                           print(key)

              遍歷所有的value:    for value in d.values():

                                           print(value)

               遍歷所有的數據項：    for item in d.items():

                                                print(items)

 

 

random模塊

  • random（）        生成一個【0,1.0）之間的隨機浮點數
  • uniform（a，b）        生成一個a到b之間的隨機浮點數
  • randint（a，b）        生成一個a到b之間的隨機整數
  • choice（<list>）        從列表中隨機返回一個元素
  • shuffle（<list>）      將列表中元素隨機打亂
  • sample（<list>，k）        從指定列表中隨機獲取K個元素

更多random模塊的方法請參考：https://docs.python.org/3/library/random.html

 

 

matplotlib模塊

  • matplotlib是一個數據可視化函數庫
  • matplotlib的子模塊pyplot提供了2D圖表制作的基本函數
  • 例子：https://matplotlib.org/gallery.html
  • 散點圖繪制：

         import matplotlib.pyplot as plt

        #x,y分別是X坐標和Y坐標的列表

        plt.scatter(x,y)

        plt.show()

 

Numpy

  • 包括：

            強大的N維數組對象array

            成熟的科學函數庫

            使用的線性代數，隨機數生成函數等

 

  • Numpy的操作對象是多維數組ndarray

            ndarray.shape 數組的維度

 

  • 創建數組：np.array(<list>)，np.arange()...
  • 改變數組形狀 reshape()
  • Numpy創建隨機數組：

            np.random.randint(a,b,size)          #創建【a,b）之間，形狀為size的數組

 

 

 


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 Python函數篇（6）-常用模塊及簡單的案列 Python常用模塊之hashlib模塊 Python常用模塊—— Colorama模塊 python常用模塊 python之常用模塊 PYTHON常用模塊和包 python常用模塊 python之路——常用模塊 Python3之常用模塊 Python之常用模塊（待更新）
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM