摘要:用匿名函數有個好處,因為函數沒有名字,不必擔心函數名沖突。和不同的是,把傳入的函數依次作用于每個元素,然后根據返回值是還是決定保留還是丟棄該元素。字符串給出當前平臺使用的行終止符。程序中間的退出,為正常退出。
列表生成式
函數的參數類型
lambda函數
map, reduce, filter, sorted函數
eval, exec, join, zip函數
itertools中的函數
copy與deepcopy函數
模塊
os、sys模塊
迭代器
生成器
迭代器
參考網站:
Python3教程: https://www.python-course.eu/...
Python之函數參數的使用:https://blog.csdn.net/jclian9...
廖雪峰Python教程: https://www.liaoxuefeng.com/w...
Python之淺談exec函數: https://blog.csdn.net/jclian9...
Python官網的itertools說明: https://docs.python.org/3.6/l...
Python-copy()與deepcopy()區別: https://blog.csdn.net/qq_3290...
copy模塊官網:https://docs.python.org/3.5/l...
列表生成式列表生成式即List Comprehensions,是Python內置的非常簡單卻強大的可以用來創建list的生成式。一般是利用原有的數據結構來生成新的列表。
</>復制代碼
# 利用range()生成[1,2,...,9,10]
list(range(1,11))
# 生成[1x1, 2x2, 3x3, ..., 10x10]
[x * x for x in range(1, 11)]
# 可以通過占位符_代表列表中的元素
[_*_ for _ in range(1,11)]
# 篩選出僅偶數的平方, 在for循環后加上if判斷語句
[x * x for x in range(1, 11) if x % 2 == 0]
# 利用占位符簡化
[_*_ for _ in range(1, 11) if not _%2]
# 兩層循環,三層循環,....
[m + n for m in "ABC" for n in "XYZ"]
[x+y+z for x in "ab" for y in "cd" for z in "ef"]
# 遍歷字典,生成列表
d = {"x": "A", "y": "B", "z": "C" }
[k + "=" + v for k, v in d.items()]
函數的參數類型
在Python中定義函數,其參數類型有:
位置參數
默認參數
可變參數
關鍵字參數
這4種參數都可以一起使用,或者只用其中某些,但是請注意,參數定義的順序必須是:位置參數、默認參數、可變參數和關鍵字參數。
可變參數以*開頭,允許傳入0個或任意個參數,這些可變參數在函數調用時自動組裝為一個tuple。關鍵字參數以**開頭,允許傳入0個或任意個參數,這些可變參數在函數調用時自動組裝為一個dict。若默認參數與可變參數放在一起,則接受完默認參數后,其后參數為可變參數。
位置參數位置參數指定名稱的必須放在未指定名稱的后面
</>復制代碼
def person(name,age,city):
s = "info: name=%s, age=%s, city=%s"%(name,age,city)
return s
print(person("Jack", 25, "NY"))
print(person(name="Jack", age=25, city="NY"))
print(person("Jack", 25, city="NY"))
# 下面的參數使用有誤,位置參數指定名稱的必須放在未指定名稱的后面
print(person(name="Jack", 25, "NY"))
默認參數
默認參數必須放在非默認參數的后面,可以該表默認參數的值
</>復制代碼
def person(name, city, age=18):
s = "info: name=%s, age=%s, city=%s"%(name,age,city)
return s
print(person("Jack", "NY"))
print(person("Jack", "NY", 20))
可變參數
可變參數以*開頭,允許傳入0個或任意個參數,這些可變參數在函數調用時自動組裝為一個tuple。函數參數的長度是可以變化的, 例如內置的sum, min, max等
</>復制代碼
def var_sum(*args):
sum = 0
for i in args:
sum += i
return sum
print(var_sum(1,2,3))
print(var_sum(1,2,3,4))
# 利用*號來分解參數
print(var_sum(*[1,2,3,4,5]))
若位置參數或默認參數與可變參數放在一起,則接受完位置參數或默認參數后,其后參數為可變參數。
</>復制代碼
def var_sum(a, *args):
sum = 0
for i in args:
sum += i
print("a is %s, sum is %s"%(a,sum))
var_sum(1,2)
var_sum(1,2,3)
關鍵字參數
關鍵字參數以**開頭,允許傳入0個或任意個參數,這些可變參數在函數調用時自動組裝為一個dict。
</>復制代碼
def test_args(**kwargs):
print("-"*20)
for key in kwargs:
print("key:", key, ",value:", kwargs[key])
print()
test_args(a=1,b=2)
test_args(a=1,b=2,c=3)
lambda函數
lambda函數即為匿名函數,用關鍵字lambda表示,冒號(:)前面的為參數,后面為返回值,不用寫return.
如:
</>復制代碼
lambda x: x*x
匿名函數有個限制,就是只能有一個表達式,一般一行代碼,不用寫return,返回值就是該表達式的結果。
用匿名函數有個好處,因為函數沒有名字,不必擔心函數名沖突。此外,匿名函數也是一個函數對象,也可以把匿名函數賦值給一個變量,再利用變量來調用該函數,即函數也是變量,此為函數式編程(functional programming)思想。
map, reduce, filter, sorted函數 map函數</>復制代碼
f = lambda x: x*x
f(5)
map()函數接收兩個參數,一個是函數,一個是Iterable,map將傳入的函數依次作用到序列的每個元素,并把結果作為新的Iterator返回。
可以直接作用于for循環的對象統稱為可迭代對象:Iterable.
舉例說明,比如我們有一個函數f(x)=x^2,要把這個函數作用在一個list [1, 2, 3, 4, 5, 6, 7, 8, 9]上,就可以用map()實現如下:
</>復制代碼
# map函數: 一一映射
def f(x):
return x * x
r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
list(r)
# 利用lambda簡化上述代碼
list(map(lambda x: x*x, range(1, 11)))
再例如: 把list所有數字轉為字符串:
</>復制代碼
list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
reduce函數
reduce把一個函數作用在一個序列[x1, x2, x3, ...]上,這個函數必須接收兩個參數,一個是函數,一個是Iterable. reduce把結果繼續和序列的下一個元素做累積計算,其效果就是:
</>復制代碼
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
比方說對一個序列求和,就可以用reduce實現:
</>復制代碼
# 導入reduce, 這很重要
from functools import reduce
def add(x, y):
return x + y
reduce(add, [1, 3, 5, 7, 9])
# 利用lambda函數簡化
reduce(lambda x,y: x+y, range(1,10,2))
作業: 利用reduce將序列[1, 3, 5, 7, 9]轉化為整數13579.
map, reduce的一個復雜例子:
將字符串列表["1", "3", "5", "7", "9"]轉化為整數13579
</>復制代碼
from functools import reduce
a = ["1", "3", "5", "7", "9"]
t = reduce(lambda x,y: 10*x+y, map(int, a))
print(t)
filter函數
Python內建的filter()函數用于過濾序列。
和map()類似,filter()也接收一個函數和一個序列。和map()不同的是,filter()把傳入的函數依次作用于每個元素,然后根據返回值是True還是False決定保留還是丟棄該元素。
例如,在一個list中,刪掉偶數,只保留奇數,可以這么寫:
</>復制代碼
list(filter(lambda x: x%2 == 1, [1, 2, 4, 5, 6, 9, 10, 15]))
sorted函數
Python內置的sorted()函數就可以對list進行排序。
</>復制代碼
sorted([36, 5, -12, 9, -21])
此外,sorted()函數還可以接收一個key函數來實現自定義的排序,例如按絕對值大小排序:
</>復制代碼
sorted([36, 5, -12, 9, -21], key=abs)
sorted(["bob", "about", "Zoo", "Credit"], key=str.lower, reverse=True)
高階函數,就是讓函數的參數能夠接收別的函數。map, reduce, filter, sorted都是高階函數。
join, zip, eval, exec函數 join函數Python中的join函數有兩個,分別為: join()和os.path.join(),具體作用如下:
join(): 連接字符串數組。將字符串、元組、列表中的元素以指定的字符(分隔符)連接生成一個新的字符串
os.path.join(): 將多個路徑組合后返回
字符串中的join()函數的使用方法:
</>復制代碼
"sep".join(seq)
sep:分隔符??梢詾榭铡?seq:要連接的元素序列。 返回一個新的字符串。
</>復制代碼
seq = ["hello","good","boy","Dido"]
print(" ".join(seq))
print("*".join(seq))
zip函數
zip() 函數用于將可迭代的對象作為參數,將對象中對應的元素打包成一個個元組,然后返回由這些元組組成的列表。
如果各個迭代器的元素個數不一致,則返回列表長度與最短的對象相同,利用 * 號操作符,可以將元組解壓為列表。
</>復制代碼
# basic use of zip
x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
print(list(zipped))
# zip for loops
for i,j in zip(x,y):
print(i, "->", j)
# unzip the list
a = [(1,2,3), (3,4,5)]
x2, y2, z2 = zip(*a)
print(x2)
print(y2)
print(z2)
# transpose a matrix
mtx = [(1, 2),
(3, 4),
(5, 6)]
print(list(zip(*mtx)))
# clustering a data series into n-length groups idiom
seq = range(1, 10)
print(list(zip(*[iter(seq)]*3)))
# dict and zip
keys = ["spam", "eggs"]
vals = [42, 1729]
d = dict(zip(keys, vals))
print(d)
eval函數
eval函數用來計算字符串表達式的值
</>復制代碼
t = eval("23")
print(t)
print(type(t))
print(eval("(1+2)*(3+4)"))
exec函數
exec()是Python的內置函數,不同于eval()函數只能執行計算數學表達式的結果的功能,exec()能夠動態地執行復雜的Python代碼,能夠十分強大。
簡單例子:
</>復制代碼
# 執行簡單的Python語句
i = 12
j = 13
exec("answer=i*j")
print("Answer is %s"%answer)
# 執行復雜的Python語句
func = "def fact(n):
return 1 if n==1 else n*fact(n-1)"
exec(func)
a = fact(5)
print(a)
exec函數還可以執行儲存在其他文件中的Python代碼,例如位于E盤的eg.txt,如下:
</>復制代碼
def fact(n):
if n==1:
return 1
else:
return n*fact(n-1)
t = fact(6)
print(t)
利用exec函數執行eg.txt中的代碼:
</>復制代碼
with open("E://eg.txt", "r") as f:
s = f.read()
exec(s)
還可以在exec()函數中加入參數,參數的傳遞可以寫成字典(dict)形式。
</>復制代碼
x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
def func():
y = 20
exec(expr)
exec(expr, {"x": 1, "y": 2})
exec(expr, {"x": 1, "y": 2}, {"y": 3, "z": 4})
func()
輸出結果為:
</>復制代碼
60
33
34
itertools模塊中的函數
Python的內建模塊itertools提供了非常有用的用于操作迭代對象的函數。
itertools模塊提供的全部是處理迭代功能的函數,它們的返回值不是list,而是Iterator,只有用for循環迭代的時候才真正計算。
無窮迭代器Iterator | Arguments | Results | Example |
---|---|---|---|
count() | start, [step] | start, start+step, start+2*step, ... | count(10) --> 10 11 12 13 14 ... |
cycle() | p | p0, p1, ... plast, p0, p1, ... | cycle("ABCD") --> A B C D A B C D ... |
repeat() | elem [,n] | elem, elem, elem, ... endlessly or up to n times | repeat(10, 3) --> 10 10 10 |
Iterator | Arguments | Results | Example |
---|---|---|---|
accumulate() | p [,func] | p0, p0+p1, p0+p1+p2, ... | accumulate([1,2,3,4,5]) --> 1 3 6 10 15 |
chain() | p, q, ... | p0, p1, ... plast, q0, q1, ... | chain("ABC", "DEF") --> A B C D E F |
chain.from_iterable() | iterable | p0, p1, ... plast, q0, q1, ... | chain.from_iterable(["ABC", "DEF"]) --> A B C D E F |
compress() | data, selectors | (d[0] if s[0]), (d[1] if s[1]), ... | compress("ABCDEF", [1,0,1,0,1,1]) --> A C E F |
dropwhile() | pred, seq | seq[n], seq[n+1], starting when pred fails | dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1 |
filterfalse() | pred, seq | elements of seq where pred(elem) is false | filterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8 |
groupby() | iterable[, keyfunc] | sub-iterators grouped by value of keyfunc(v) | |
islice() | seq, [start,] stop [, step] | elements from seq[start:stop:step] | islice("ABCDEFG", 2, None) --> C D E F G |
starmap() | func, seq | func(seq[0]), func(seq[1]), ... | starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000 |
takewhile() | pred, seq | seq[0], seq[1], until pred fails | takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4 |
tee() | it, n | it1, it2, ... itn splits one iterator into n | |
zip_longest() | p, q, ... | (p[0], q[0]), (p[1], q[1]), ... | zip_longest("ABCD", "xy", fillvalue="-") --> Ax By C- D- |
groupby()函數
groupby()把迭代器中相鄰的重復元素挑出來放在一起:
</>復制代碼
for key, group in itertools.groupby("AAABBBCCAAA"):
print(key, list(group))
A ["A", "A", "A"]
B ["B", "B", "B"]
C ["C", "C"]
A ["A", "A", "A"]
實際上挑選規則是通過函數完成的,只要作用于函數的兩個元素返回的值相等,這兩個元素就被認為是在一組的,而函數返回值作為組的key。
另一個例子
</>復制代碼
# 按身高歸類
from itertools import *
def height_class(h):
if h>180:
return "tall"
elif h<160:
return "short"
else:
return "middle"
friends = [191, 158, 159, 165, 170, 177, 181, 182, 190]
for m,n in groupby(friends,key = height_class):
print(m)
print(list(n))
作業: 對于一組身高的數據(list),利用上面代碼給出的身高標準,將所以的tall, short, middle歸為一類。注意與groupby()函數的區別。
tee()函數
把一個迭代器分為n個迭代器, 返回一個元組.默認是兩個
</>復制代碼
from itertools import *
a = "hello"
c, d, e = tee(iter(a), 3)
for i, j, k in zip(c, d, e):
print(i, j, k)
組合生成器
Iterator | Arguments | Results |
---|---|---|
product() | p, q, ... [repeat=1] | cartesian product, equivalent to a nested for-loop |
permutations() | p[, r] | r-length tuples, all possible orderings, no repeated elements |
combinations() | p, r | r-length tuples, in sorted order, no repeated elements |
combinations_with_replacement() | p, r | r-length tuples, in sorted order, with repeated elements |
product("ABCD", repeat=2) | AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD | |
permutations("ABCD", 2) | AB AC AD BA BC BD CA CB CD DA DB DC | |
combinations("ABCD", 2) | AB AC AD BC BD CD | |
combinations_with_replacement("ABCD", 2) | AA AB AC AD BB BC BD CC CD DD |
copy: 淺拷貝(shallow copy), deepcopy: 深拷貝(deep copy).
</>復制代碼
我們尋常意義的復制就是深復制,即將被復制對象完全再復制一遍作為獨立的新個體多帶帶存在。所以改變原有被復制對象不會對已經復制出來的新對象產生影響。
而淺復制并不會產生一個獨立的對象多帶帶存在,他只是將原有的數據塊打上一個新標簽,所以當其中一個標簽被改變的時候,數據塊就會發生變化,另一個標簽也會隨之改變。這就和我們尋常意義上的復制有所不同了。
對于簡單的 object,用 shallow copy 和 deep copy 沒區別
復雜的 object, 如 list 中套著 list 的情況,shallow copy 中的 子list,并未從原 object 真的「獨立」出來。也就是說,如果你改變原 object 的子 list 中的一個元素,你的 copy 就會跟著一起變。這跟我們直覺上對「復制」的理解不同。
例子:
</>復制代碼
from copy import copy, deepcopy
#origin 里邊有三個元素:1,2,[3, 4]
origin = [1, 2, [3, 4]]
# cop1為淺拷貝,cop2為深拷貝
cop1 = copy(origin)
cop2 = deepcopy(origin)
# cop1是否與cop2內容相同
print(cop1 == cop2)
# cop1是否與cop2為同一個引用
print(cop1 is cop2)
# 改變origin中嵌套列表中的元素
origin[2][0] = "hey"
# 查看輸出
print(origin)
print(cop1)
print(cop2)
# 改變origin中嵌套列表中的元素
origin[1] = "hello"
# 查看輸出
print(origin)
print(cop1)
print(cop2)
輸出結果:
</>復制代碼
True
False
[1, 2, ["hey", 4]]
[1, 2, ["hey", 4]]
[1, 2, [3, 4]]
[1, "hello", ["hey", 4]]
[1, 2, ["hey", 4]]
[1, 2, [3, 4]]
模塊
在Python中,一個Python文件就是一個模塊。
模塊讓你能夠有邏輯地組織你的 Python 代碼段。
把相關的代碼分配到一個模塊里能讓你的代碼更好用,更易懂。
模塊能定義函數,類和變量,模塊里也能包含可執行的代碼。
一個簡單的模塊例子:
hello.py
</>復制代碼
def say_hello(name):
s = "hello, %s!"%name
return s
使用模塊:
import module
from module import ...
</>復制代碼
import hello
print(hello.say_hello("Lee"))
from hello import say_hello
print(say_hello("Jack"))
os、sys模塊
os模塊
os模塊包含普遍的操作系統功能。
os常用方法及屬性os.sep 可以取代操作系統特定的路徑分隔符。windows下為 “”
os.name字符串指示你正在使用的平臺。比如對于Windows,它是"nt",而對于Linux/Unix用戶,它是"posix"。
os.getcwd() 函數得到當前工作目錄,即當前Python腳本工作的目錄路徑。
os.getenv() 獲取一個環境變量,如果沒有返回none
os.putenv(key, value) 設置一個環境變量值
os.listdir(path) 返回指定目錄下的所有文件和目錄名。
os.remove(path) 函數用來刪除一個文件。
os.system(command) 函數用來運行shell命令。
os.linesep 字符串給出當前平臺使用的行終止符。例如,Windows使用"rn",Linux使用"n"而Mac使用"r"。
os.curdir: 返回當前目錄(".")
os.chdir(dirname): 改變工作目錄到dirname
os.path常用方法:os.path.isfile()和os.path.isdir()函數分別檢驗給出的路徑是一個文件還是目錄。
os.path.existe()函數用來檢驗給出的路徑是否真地存在
os.path.getsize(name):獲得文件大小,如果name是目錄返回0L
os.path.abspath(name):獲得絕對路徑
os.path.normpath(path):規范path字符串形式
os.path.split(path) :將path分割成目錄和文件名二元組返回。
os.path.splitext():分離文件名與擴展名
os.path.join(path,name):連接目錄與文件名或目錄;使用“”連接
os.path.basename(path):返回文件名
os.path.dirname(path):返回文件路徑
sys模塊提供了一系列有關Python運行環境的變量和函數。
sys模塊的常用方法sys.argv: 實現從終端向程序傳遞參數。
sys.exit([arg]): 程序中間的退出,arg=0為正常退出。
sys.getdefaultencoding(): 獲取系統當前編碼,一般默認為ascii。
sys.setdefaultencoding(): 設置系統默認編碼,執行dir(sys)時不會看到這個方法,在解釋器中執行不通過,可以先執行reload(sys),在執行 setdefaultencoding("utf8"),此時將系統默認編碼設置為utf8。(見設置系統默認編碼 )
sys.getfilesystemencoding(): 獲取文件系統使用編碼方式,Windows下返回"mbcs",mac下返回"utf-8".
sys.path: 獲取指定模塊搜索路徑的字符串集合,可以將寫好的模塊放在得到的某個路徑下,就可以在程序中import時正確找到。
sys.platform: 獲取當前系統平臺。
sys.stdin, sys.stdout, sys.stderr: stdin , stdout , 以及stderr 變量包含與標準I/O 流對應的流對象. 如果需要更好地控制輸出,而print 不能滿足你的要求, 它們就是你所需要的. 你也可以替換它們, 這時候你就可以重定向輸出和輸入到其它設備( device ), 或者以非標準的方式處理它們
生成器通過列表生成式,我們可以直接創建一個列表。但是,受到內存限制,列表容量肯定是有限的。而且,創建一個包含100萬個元素的列表,不僅占用很大的存儲空間,如果我們僅僅需要訪問前面幾個元素,那后面絕大多數元素占用的空間都白白浪費了。
所以,如果列表元素可以按照某種算法推算出來,那我們是否可以在循環的過程中不斷推算出后續的元素呢?這樣就不必創建完整的list,從而節省大量的空間。在Python中,這種一邊循環一邊計算的機制,稱為生成器:generator。
創建generator的辦法:
把一個列表生成式的[]改成()
yield關鍵字
將列表的[]改成()的例子:</>復制代碼
# 列表生成式
L = [x * x for x in range(10)]
print(type(L))
# 創建生成器
g = (x * x for x in range(10))
print(type(g))
# 獲取下一個返回值
# 當沒有更多元素時,會拋出StopIteration錯誤
print(next(g))
print(next(g))
print(next(g))
# for循環
for n in g:
print(n)
通過yield創建生成器
</>復制代碼
# 普通方法生成斐波拉契數列
# 前幾個斐波拉契數
def fib1(max):
n, a, b = 0, 0, 1
while n < max:
print(b)
a, b = b, a + b
n = n + 1
return "done"
fib1(6)
# 通過yield創建生成器
# 注意yield的執行流程
def fib2(max):
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a + b
n = n + 1
return "done"
# 將生成器函數賦值給變量f
f = fib2(6)
print(type(f))
for n in f:
print(n)
generator和函數的執行流程不一樣。函數是順序執行,遇到return語句或者最后一行函數語句就返回。而變成generator的函數,在每次調用next()的時候執行,遇到yield語句返回,再次執行時從上次返回的yield語句處繼續執行。
generator執行流程的理解:</>復制代碼
def odd():
print("step 1")
yield 1
print("step 2")
yield(3)
print("step 3")
yield(5)
o = odd()
print(next(o))
print(next(o))
print(next(o))
迭代器
可以直接作用于for循環的數據類型有以下幾種:
集合數據類型,如list、tuple、dict、set、str等;
generator,包括生成器和帶yield的generator function。
這些可以直接作用于for循環的對象統稱為可迭代對象:==Iterable==。
可以使用isinstance()判斷一個對象是否是Iterable對象:
</>復制代碼
from collections import Iterable
# 判斷空列表是否為Iterable對象
# True
print(isinstance([], Iterable))
# 判斷空集合是否為Iterable對象
# True
print(isinstance({}, Iterable))
# 判斷字符是否為Iterable對象
# True
print(isinstance("abc", Iterable))
# 判斷生成器是否為Iterable對象
# True
print(isinstance((x for x in range(10)), Iterable))
# 判斷數字否為Iterable對象
# False
print(isinstance(100, Iterable))
可以被next()函數調用并不斷返回下一個值的對象稱為迭代器:Iterator。
可以使用isinstance()判斷一個對象是否是Iterator對象:
</>復制代碼
from collections import Iterator
# 判斷生成器是否為Iterator對象
# True
print(isinstance((x for x in range(10)), Iterator))
# 判斷空列表是否為Iterator對象
# False
print(isinstance([], Iterator))
# 判斷空集合是否為Iterator對象
# False
print(isinstance({}, Iterator))
# 判斷字符串是否為Iterator對象
# False
print(isinstance("abc", Iterator))
生成器都是Iterator對象,但list、dict、str雖然是Iterable,卻不是Iterator。
把list、dict、str等Iterable變成Iterator可以使用iter()函數。
文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。
轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/41821.html
摘要:正文總所周知,和根本就是兩個東西,每次因為這個兼容性的問題都會把自己搞瘋。提供了模塊,把下一個新版本的特性導入到當前版本,于是我們就可以在當前版本中測試一些新版本的特性。傳送門不多,才個。 寫在前面 我是在學習cs231n的assignment3的課程,發現里面的代碼大量頻繁出現了這個庫,那我就很奇怪了,為什么有個future這個奇怪名字的庫會出現呢?到底這個庫又有什么用?下面就讓我為...
摘要:返回非負隨機數大于或等于零且小于的位帶符號整數。返回一個指定范圍內的隨機數返回的隨機數的下界隨機數可取該下界值。其中參數是下限,參數是上限,生成的隨機數。如,結果相當于從序列中獲取一個隨機數。 你真的懂隨機數? Author : Jasper YangSchool : Bupt Q:為什么要寫這篇文章?A:因為我發現在最近的科學計算中,常常遇到隨機數,所有的隨機數都是基于0,1隨機,而...
摘要:很簡單,這個模塊實現了開辟一塊共享內存空間,就好比中的方法一樣,有興趣的同學可以去查閱。查了下資料,返回的對象控制了一個進程,可用于多進程之間的安全通信,其支持的類型有和等。 有關于 multiprocessing 中共享變量的問題 現在的cpu都很強大,比方我用的至強2620有24核可以同時工作,并行執行進程程序。這在計算密集型的程序是很需要的,如沙漠中的綠洲,令人重獲新生。那么,問...
摘要:在第一次執行循環時該變量為是一個布爾值在最后一次執行循環時被置為。注冊自定義修改顯示字段管理后臺默認顯示,在中添加返回值方法,修改顯示效果。 理解上下文 render(request,x.html,context) request:請求的固定寫法。 x.html:模板,需要填補丁的模板。 context:上下文,填充模板的補丁。 模板的使用流程 寫模板,創建Template對象,用...
閱讀 3746·2023-04-25 18:41
閱讀 1180·2021-11-11 16:55
閱讀 1833·2021-09-22 15:54
閱讀 3075·2021-09-22 15:51
閱讀 3549·2019-08-30 15:55
閱讀 1945·2019-08-30 14:19
閱讀 1284·2019-08-29 10:57
閱讀 1705·2019-08-29 10:56