主頁 > 後端開發 > 詳解python三大器——迭代器、生成器、裝飾器

詳解python三大器——迭代器、生成器、裝飾器

2021-10-20 08:32:43 後端開發

  • 迭代器
    聊迭代器前我們要先清楚迭代的概念：通常來講從一個物件中依次取出資料，這個程序叫做遍歷，這個手段稱為迭代(重復執行某一段代碼塊，并將每一次迭代得到的結果作為下一次迭代的初始值)，

    • 可迭代物件(iterable)：是指該物件可以被用于for…in…回圈，例如：集合，串列，元祖，字典，字串，迭代器等，

      • 在python中如果一個物件實作了 __iter__方法，我們就稱之為可迭代物件，可以查看set\list\tuple…等原始碼內部均實作了__iter__方法
      • 如果一個物件未實作__iter__方法，但是對其使用for…in則會拋出TypeError: ‘xxx’ object is not iterable
      • 可以通過isinstance(obj,Iterable)來判斷物件是否為可迭代物件，如：
from collections.abc import Iterable
a: int = 1
print(isinstance(a, Iterable))  # False
b: str = "lalalalala" 
print(isinstance(b, Iterable))  # True
c: set = set([1, 2])
print(isinstance(c, Iterable))  # True

我們也可以自己實作__iter__來將一個類實體物件變為可迭代物件：

class MyIterable:
	def __iter__(self):
		pass


print(isinstance(MyIterable(), Iterable)) # True

  • 迭代器：對可迭代物件進行迭代的方式或容器，并且需要記錄當前迭代進行到的位置，

    • 在python中如果一個物件同時實作了__iter__和__next__(獲取下一個值)方法，那么它就是一個迭代器物件，
    • 可以通過內置函式next(iterator)，來獲取當前迭代的值
    • 迭代器一定是可迭代物件，可迭代物件不一定是迭代器，
    • 如果可迭代物件遍歷完后繼續呼叫next()，則會拋出：StopIteration例外，
      自己實作一個迭代器物件：
from collections.abc import Iterator, Iterable

class MyIterator:
	def __init__(self, array_list):
		self.array_list = array_list
		self.index = 0

	def __iter__(self):
		return self

	def __next__(self):
		if self.index < len(self.array_list):
			val = self.array_list[self.index]
			self.index += 1
			return val
		else:
			raise StopIteration

# 父類如果是迭代器，子類也將是迭代器
class MySubIterator(MyIterator):
	def __init__(self):
		pass


myIterator = MyIterator([1, 2, 3, 4])
# 判斷是否為可迭代物件
print(isinstance(myIterator, Iterable))  # True
# 判斷是否為迭代器
print(isinstance(myIterator, Iterator))  # True
# 子類實體化
mySubIterator = MySubIterator()
print(isinstance(mySubIterator, Iterator))  # True
# 進行迭代
print(next(myIterator))  # 1
print(next(myIterator))  # 2
print(next(myIterator))  # 3
print(next(myIterator))  # 4
print(next(myIterator))  # raise StopIteration

迭代器優缺點：

 - 優點：迭代器物件表示的是一個資料流，可以在需要時才去呼叫next來獲取一個值；因而本身在記憶體中始終只保留一個值，對于記憶體占用小可以存放無限資料流，優于其他容器需要一次將所有元素都存放進記憶體，如：串列、集合、字典...等
 - 缺點：1.無法獲取存放的元素長度，除非取完計數，2.只能向后取值，next()永遠回傳的是下一個值，取值不靈活，無法取出指定值(無法像字典的key,或串列的下標)，而且迭代器的生命周期是一次性的元素被迭代完則生命周期結束
  • 生成器
    定義：在Python中，一邊回圈一邊計算的機制，稱為生成器：generator；同時生成器物件也是迭代器物件，所以他有迭代器的特性；例如支持for回圈、next()方法…等
    作用：物件中的元素是按照某種演算法推算出來的，在回圈的程序中不斷推算出后續的元素，這樣就不必創建完整的list，從而節省大量的空間，
    • 簡單生成器：通過將串列生成式[]改成()即可得到一個生成器物件
# 串列生成式
_list = [i for i in range(10)]
print(type(_list))  # <class 'list'>
print(_list)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 生成器
_generator = (i for i in range(10))
print(type(_generator))  # <class 'generator'>
print(_generator)  # <generator object <genexpr> at 0x7fbcd92c9ba0>
# 生成器物件取值
print(_generator.__next__())  # 0
print(next(_generator)) # 1
# 注意從第三個元素開始了！
for x in _generator:
	print(x)  # 2，3，4，5，6，7，8，9

因為生成器物件也有迭代器的特性，所以元素迭代完后繼續呼叫next()方法則會引發StopIteration，

  • 函式物件生成器：帶yield陳述句的函式物件的回傳值則是個生成器物件，
def gen_generator():
	yield 1


def generator():
	return 1


print(gen_generator(), type(gen_generator()))  
# <generator object gen_generator at 0x7fe68b2c8b30> <class 'generator'>
print(generator(), type(generator()))  
# 1 <class 'int'>

他與普通函式回傳值有所不同，普通函式運行到return陳述句則直接回傳代碼不再執行；而生成器物件會運行到yield后回傳，再下次呼叫時從yield陳述句后繼續執行，如：
在這里插入圖片描述
注意：yield 一次只會回傳一個元素，即使回傳的元素是個可迭代物件，也是一次性回傳

def gen_generator2():
	yield [1, 2, 3]


s = gen_generator2()
print(next(s))  # [1, 2, 3]
  • yield生成器高級應用：
    • send()方法，傳遞yield的值
      在這里插入圖片描述
      借助send我們可以實作一個簡單的生產者-消費者模式如：
def consumer():
	r = ''
	while True:
		n = yield r
		if not n:
			return
		print(f'[CONSUMER] Consuming get params.. ({n})')
		if n == 3:
			r = '500 Error'
		else:
			r = '200 OK'


def produce(c):
	c.send(None)  # 啟動生成器
	n = 0
	while n < 5:
		n = n + 1
		print(f'[PRODUCER] Producing with params.. ({n})')
		r = c.send(n)  # 一旦n有值，則切換到consumer執行
		print(f'[PRODUCER] Consumer return : [{r}]')
		if not r.startswith('200'):
			print("消費者回傳服務例外，則結束生產，并關閉消費者")
			c.close()  # 關閉生成器
			break


consume = consumer()
produce(consume)

# [PRODUCER] Producing with params.. (1)
# [CONSUMER] Consuming get params.. (1)
# [PRODUCER] Consumer return : [200 OK]
# [PRODUCER] Producing with params.. (2)
# [CONSUMER] Consuming get params.. (2)
# [PRODUCER] Consumer return : [200 OK]
# [PRODUCER] Producing with params.. (3)
# [CONSUMER] Consuming get params.. (3)
# [PRODUCER] Consumer return : [500 Error]
# 消費者回傳服務例外，則結束生產，并關閉消費者
  • yield from iterable 語法，基本作用為：回傳一個生成器物件，提供一個“資料傳輸的管道”，yield from iterable 是 for item in iterable: yield item的縮寫；并且內部幫我們實作了很多例外處理，簡化了編碼復雜度，
    • yield 無法獲取生成器return的回傳值：
def my_generator(n, end_case):
	for i in range(n):
		if i == end_case:
			return f'當 i==`{i}`時，中斷程式，'
		else:
			yield i


g = my_generator(5, 2)  # 呼叫

for _i in g:  # for回圈不會顯式觸發例外，故而無法獲取到return的值
	print(_i)

# 輸出：
# 0
# 1

從上面的例子可以看出，for迭代陳述句不會顯式觸發例外，故而無法獲取到return的值，迭代到2的時候遇到return陳述句，隱式的觸發了StopIteration例外，就終止迭代了，但是在程式中不會顯示出來，

可以通過next()顯示的觸發StopIteration例外來獲取回傳值:

def my_generator2(n, end_case):
	for i in range(n):
		if i == end_case:
			return f'當 i==`{i}`時，中斷程式，'
		else:
			yield i


g = my_generator2(5, 2)  # 呼叫

try:
	print(next(g))  # 0
	print(next(g))  # 1
	print(next(g))  # 此處要觸發end_case了
except StopIteration as exc:
	print(exc.value)  # 當 i==`2`時，中斷程式，

使用yield from 可以簡化成：

def my_generator3(n, end_case):
	for i in range(n):
		if i == end_case:
			return f'當 i==`{i}`時，中斷程式，'
		else:
			yield i


def wrap_my_generator(generator):  # 將my_generator的回傳值包裝成一個生成器
	result = yield from generator
	yield result


g = my_generator3(5, 2)  # 呼叫
for _ in wrap_my_generator(g):
	print(_)

# 輸出：
# 0
# 1
# 當 i==`2`時，中斷程式，

yield from 有以下幾個概念名詞：
1、呼叫方：呼叫委派生成器的客戶端（呼叫方）代碼（上文中的wrap_my_generator(g)）
2、委托生成器：包含yield from運算式的生成器函式(包裝)，作用就是提供一個資料傳輸的管道（上文中的wrap_my_generator）
3、子生成器：yield from后面加的生成器函式（上文中的my_generator）
呼叫方是通過這個 “包裝函式” 來與生成器進行互動的，即“呼叫方——>委托生成器——>生成器函式”
下面有個例子幫助大家理解（該🌰參考于博客）：

# 子生成器
def average_gen():
	total = 0
	count = 0
	average = 0
	while True:
		new_num = yield average
		if new_num is None:
			break
		count += 1
		total += new_num
		average = total / count

	# 每一次return，都意味著當前協程結束，
	return total, count, average


# 委托生成器
def proxy_gen():
	while True:
		# 只有子生成器要結束（return）了，yield from左邊的變數才會被賦值，后面的代碼才會執行，
		total, count, average = yield from average_gen()
		print("總共傳入 {} 個數值， 總和：{}，平均數：{}".format(count, total, average))


# 呼叫方
def main():
	calc_average = proxy_gen()
	next(calc_average)  # 激活協程
	calc_average.send(10)  # 傳入：10
	calc_average.send(None)  # 結束協程
	print("================== 重開協程 ===================")
	calc_average.send(20)  # 傳入：20
	calc_average.send(30)  # 傳入：30
	calc_average.send(None)  # 結束協程


if __name__ == '__main__':
	main()
# 輸出：
# 總共傳入 1 個數值， 總和：10，平均數：10.0
# ================== 重開協程 ===================
# 總共傳入 2 個數值， 總和：50，平均數：25.0

在這里插入圖片描述
有興趣的同學可以結合圖和下方一起理解：

  1. 迭代器（即可指子生成器）產生的值直接返還給呼叫者
  2. 任何使用send()方法發給委派生產器（即外部生產器）的值被直接傳遞給迭代器，如果send值是None，則呼叫迭代器next()方法；如果不為None，則呼叫迭代器的send()方法，如果對迭代器的呼叫產生StopIteration例外，委派生產器恢復繼續執行yield from后面的陳述句；若迭代器產生其他任何例外，則都傳遞給委派生產器，
  3. 子生成器可能只是一個迭代器，并不是一個作為協程的生成器，所以它不支持.throw()和.close()方法,即可能會產生AttributeError 例外，
  4. 除了GeneratorExit 例外外的其他拋給委派生產器的例外，將會被傳遞到迭代器的throw()方法，如果迭代器throw()呼叫產生了StopIteration例外，委派生產器恢復并繼續執行，其他例外則傳遞給委派生產器，
  5. 如果GeneratorExit例外被拋給委派生產器，或者委派生產器的close()方法被呼叫，如果迭代器有close()的話也將被呼叫，如果close()呼叫產生例外，例外將傳遞給委派生產器，否則，委派生產器將拋出GeneratorExit 例外，
  6. 當迭代器結束并拋出例外時，yield from運算式的值是其StopIteration 例外中的第一個引數，
  7. 一個生成器中的return expr陳述句將會從生成器退出并拋出 StopIteration(expr)例外，
  • ??裝飾器(非常實用！)
    講裝飾器之前要先了解兩個概念：
    • 物件參考 ：物件名僅僅只是個系結記憶體地址的變數
def func():   # 函式名僅僅只是個系結記憶體地址的變數       
	print("i`m running") 
                     
# 這是呼叫                       
func()  # i`m running
# 這是物件參考，參考的是記憶體地址        
func2 = func  
print(func2 is func)  # True
# 通過參考進行呼叫  
func2()  # i`m running
  • 閉包：定義一個函式A，然后在該函式內部再定義一個函式B，并且B函式用到了外邊A函式的變數
def out_func():
	out_a = 10

	def inner_func(inner_x):
		return out_a + inner_x

	return inner_func


out = out_func()
print(out)  # <function out_func.<locals>.inner_func at 0x7ff378af5c10> out_func回傳的是inner_func的記憶體地址
print(out(inner_x=2))  # 12

裝飾器和閉包不同點在于：裝飾器的入參是函式物件，閉包入參是普通資料物件

def decorator_get_function_name(func):
	"""
	獲取正在運行函式名
	:return:
	"""

	def wrapper(*arg):
		"""
		wrapper
		:param arg:
		:return:
		"""
		print(f"當前運行方法名：{func.__name__}  with  params: {arg}")
		return func(*arg)

	return wrapper


@decorator_get_function_name
def test_func_add(x, y):
	print(x + y)


@decorator_get_function_name
def test_func_sub(x, y):
	print(x - y)


test_func_add(1, 2)
# 當前運行方法名：test_func_add  with  params: (1, 2)
# 3
test_func_sub(3, 5)
# 當前運行方法名：test_func_sub  with  params: (3, 5)
# -2

常用于如鑒權校驗，例如筆者會用于登陸校驗：

def login_check(func):
    def wrapper(request, *args, **kwargs):
        if not request.session.get('login_status'):
            return HttpResponseRedirect('/api/login/')
        return func(request, *args, **kwargs)

    return wrapper

@login_check
def edit_config():
	pass

裝飾器內部的執行邏輯：

"""
>  1. def login_check(func):  ==>將login_check函式加載到記憶體
>  ....
>  @login_check  ==>此處已經在記憶體中將login_check這個函式執行了！；并不需要等edit_config()實體化呼叫
>  2. 上例@login_check內部會執行以下操作：
>	  2.1 執行login_check函式，并將 @login_check 下面的 函式(edit_config) 作為login_check函式的引數，即：@login_check 等價于 login_check(edit_config)
>     2.2 內部就會去執行：
      def wrapper(*args):
          # 校驗session...
          return func(request, *args, **kwargs)   # func是引數，此時 func 等于 edit_config，此處相當于edit_config(request, *args, **kwargs)
      return wrapper     # 回傳的 wrapper，wrapper代表的是函式物件，非函式實體化物件
      2.3 其實就是將原來的 edit_config 函式塞進另外一個函式中,另一個函式當中可以做一些操作；再執行edit_config
      2.4 將執行完的 login_check 函式回傳值(也就是 wrapper物件)將此回傳值再重新賦值給新 edit_config，即：
      2.5 新edit_config = def wrapper:
             # 校驗session...
            return 原來edit_config(request, *args, **kwargs) 
>  3. 也就是新edit_config()=login_check(edit_config):wrapper(request, *args, **kwargs):return edit_config(request, *args, **kwargs) 有點繞，大家看步驟細細理解，
"""

同樣一個函式也可以使用多個裝飾器進行裝飾，執行順序從上到下

from functools import wraps

def w1(func):
	@wraps(func)
	def wrapper(*args, **kwargs):
		print("這里是第一個校驗")
		return func(*args, **kwargs)

	return wrapper


def w2(func):
	@wraps(func)
	def wrapper(*args, **kwargs):
		print("這里是第二個校驗")
		return func(*args, **kwargs)

	return wrapper


def w3(func):
	def wrapper(*args, **kwargs):
		print("這里是第三個校驗")
		return func(*args, **kwargs)

	return wrapper


@w2  # 這里其實是w2(w1(f1))
@w1  # 這里是w1(f1)
def f1():
	print(f"i`m f1, at {f1}")


@w3
def f2():
	print(f"i`m f2, at {f2}")

# ====================== 實體化階段 =====================
f1()
# 這里是第二個校驗
# 這里是第一個校驗
# i`m f1, at <function f1 at 0x7febc52f5e50>
f2()
# 這里是第三個校驗
# i`m f2, at <function w3.<locals>.inner at 0x7febc52f5f70>

有同學可能要好奇 為什么f1物件列印的是“<function f1 at 0x7febc52f5e50>”，f2物件列印的是“<function w3..wrapper at 0x7febc52f5f70>”（也就是步驟2.5造成的，賦的值是wrapper物件），這就跟w1和w2 內部wrapper使用的wraps裝飾器有關系了，
wraps的作用是：被修飾的函式（也就是里面的func）的一些屬性值賦值給修飾器函式（wrapper）包括元資訊和“函式物件”等，

同時裝飾器也可以接受引數：

def decorator_get_function_duration(enable):
	"""
	:param enable:  是否需要統計函式執行耗時
	:return: 
	"""
	print("this is decorator_get_function_duration")

	def inner(func):
		print('this is inner in decorator_get_function_duration')

		@wraps(func)
		def wrapper(*args, **kwargs):
			print('this is a wrapper in decorator_get_function_duration.inner')
			if enable:
				start = time.time()
				print(f"函式執行前：{start}")
				result = func(*args, **kwargs)
				print('[%s]`s enable was %s it`s duration : %.3f s ' % (func.__name__, enable, time.time() - start))
			else:
				result = func(*args, **kwargs)
			return result

		return wrapper

	return inner


def decorator_1(func):
	print('this is decorator_1')

	@wraps(func)
	def wrapper(*args, **kwargs):
		print('this is a wrapper in decorator_1')
		return func(*args, **kwargs)

	return wrapper


def decorator_2(func):
	print('this is decorator_2')

	@wraps(func)
	def wrapper(*args, **kwargs):
		print('this is a wrapper in decorator_2')
		return func(*args, **kwargs)

	return wrapper


@decorator_1 # 此處相當:decorator_1(decorator_2(decorator_get_function_duration(enable=True)(fun)))
@decorator_2 # = decorator_2(decorator_get_function_duration(enable=True)(fun))
@decorator_get_function_duration(enable=True)  # = decorator_get_function_duration(enable=True)(fun)
def fun():
	time.sleep(2)
	print("fun 執行完了～")


fun()
# ======== enable=False ============
"""
this is decorator_get_function_duration
this is inner in decorator_get_function_duration
this is decorator_2
this is decorator_1
this is a wrapper in decorator_1
this is a wrapper in decorator_2
this is a wrapper in decorator_get_function_duration.inner
fun 執行完了～
"""
# ======== enable=True ============
"""
this is decorator_get_function_duration
this is inner in decorator_get_function_duration
this is decorator_2
this is decorator_1
this is a wrapper in decorator_1
this is a wrapper in decorator_2
this is a wrapper in decorator_get_function_duration.inner
函式執行前：1634635708.648994
fun 執行完了～
[fun]`s enable was True it`s duration : 2.002 s 
"""

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/325601.html

標籤：python

上一篇：Python處理json字串為什么不建議使用eval()

下一篇：使用purrr標記許多模型的回歸樣本

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂