主頁 > 後端開發 > 幾種常見的Python資料結構

幾種常見的Python資料結構

2023-05-09 07:22:56 後端開發

摘要：本文主要為大家講解在Python開發中常見的幾種資料結構，

本文分享自華為云社區《Python的常見資料結構》，作者： timerring ，

資料結構和序列

元組

元組是一個固定長度，不可改變的Python序列物件，創建元組的最簡單方式，是用逗號分隔一列值：

In [1]: tup = 4, 5, 6

當用復雜的運算式定義元組，最好將值放到圓括號內，如下所示：

In [3]: nested_tup = (4, 5, 6), (7, 8)
In [4]: nested_tup
Out[4]: ((4, 5, 6), (7, 8))

用 tuple 可以將任意序列或迭代器轉換成元組：

In [5]: tuple([4, 0, 2])
Out[5]: (4, 0, 2)
In [6]: tup = tuple('string')
In [7]: tup
Out[7]: ('s', 't', 'r', 'i', 'n', 'g')

可以用方括號訪問元組中的元素，和C、C++、JAVA等語言一樣，序列是從0開始的：

In [8]: tup[0]
Out[8]: 's'

元組中存盤的物件可能是可變物件，一旦創建了元組，元組中的物件就不能修改了：

如果元組中的某個物件是可變的，比如串列，可以在原位進行修改：

In [11]: tup[1].append(3)
In [12]: tup
Out[12]: ('foo', [1, 2, 3], True)

可以用加號運算子將元組串聯起來：

In [13]: (4, None, 'foo') + (6, 0) + ('bar',)
Out[13]: (4, None, 'foo', 6, 0, 'bar')

元組乘以一個整數，像串列一樣，會將幾個元組的復制串聯起來：

In [14]: ('foo', 'bar') * 4
Out[14]: ('foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'bar')

物件本身并沒有被復制，只是參考了它，

拆分元組

如果你想將元組賦值給類似元組的變數，Python會試圖拆分等號右邊的值：

In [15]: tup = (4, 5, 6)
In [16]: a, b, c = tup
In [17]: b
Out[17]: 5

即使含有元組的元組也會被拆分：

In [18]: tup = 4, 5, (6, 7)
In [19]: a, b, (c, d) = tup
In [20]: d
Out[20]: 7

使用這個功能，你可以很容易地替換變數的名字，其它語言可能是這樣：

tmp = a
a = b
b = tmp

但是在Python中，替換可以這樣做：

In [21]: a, b = 1, 2
In [22]: a
Out[22]: 1
In [23]: b
Out[23]: 2
In [24]: b, a = a, b
In [25]: a
Out[25]: 2
In [26]: b
Out[26]: 1

變數拆分常用來迭代元組或串列序列：

In [27]: seq = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
In [28]: for a, b, c in seq:
 ....: print('a={0}, b={1}, c={2}'.format(a, b, c))
a=1, b=2, c=3
a=4, b=5, c=6
a=7, b=8, c=9

另一個常見用法是從函式回傳多個值，后面會詳解，

Python最近新增了更多高級的元組拆分功能，允許從元組的開頭“摘取”幾個元素，它使用了特殊的語法 *rest ，抓取剩余的部分組成串列：

In [29]: values = 1, 2, 3, 4, 5
In [30]: a, b, *rest = values
In [31]: a, b
Out[31]: (1, 2)
In [32]: rest
Out[32]: [3, 4, 5]

rest的部分是想要舍棄的部分，rest的名字不重要，作為慣用寫法，許多Python程式員會將不需要的變數使用下劃線：

In [33]: a, b, *_ = values

tuple方法

因為元組的大小和內容不能修改，它的實體方法都很少，其中一個很有用的就是count（也適用于串列），它可以統計某個值出現頻率：

In [34]: a = (1, 2, 2, 2, 3, 4, 2)
In [35]: a.count(2)
Out[35]: 4

串列

與元組對比，串列的長度可變、內容可以被修改，你可以用方括號定義，或用list函式：

In [37]: tup = ('foo', 'bar', 'baz')
In [38]: b_list = list(tup)
In [39]: b_list
Out[39]: ['foo', 'bar', 'baz']

list函式常用來在資料處理中物體化迭代器或生成器：

In [42]: gen = range(10)
In [43]: gen
Out[43]: range(0, 10)
In [44]: list(gen)
Out[44]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

添加和洗掉元素

用append在串列末尾添加元素：

In [45]: b_list.append('dwarf')
In [46]: b_list
Out[46]: ['foo', 'peekaboo', 'baz', 'dwarf']

insert可以在特定的位置插入元素：

In [47]: b_list.insert(1, 'red')
In [48]: b_list
Out[48]: ['foo', 'red', 'peekaboo', 'baz', 'dwarf']

插入的序號必須在0和串列長度之間，

警告：與append相比，insert耗費的計算量大，因為對后續元素的參考必須在內部遷移，以便為新元素提供空間，如果要在序列的頭部和尾部插入元素，你可能需要使用collections.deque，一個雙尾部佇列，

insert的逆運算是 pop，它移除并回傳指定位置的元素**：

In [49]: b_list.pop(2)
Out[49]: 'peekaboo'
In [50]: b_list
Out[50]: ['foo', 'red', 'baz', 'dwarf']

可以用remove去除某個值，remove會先尋找第一個值并除去：

In [51]: b_list.append('foo')
In [52]: b_list
Out[52]: ['foo', 'red', 'baz', 'dwarf', 'foo']
In [53]: b_list.remove('foo')
In [54]: b_list
Out[54]: ['red', 'baz', 'dwarf', 'foo']

如果不考慮性能，使用append和remove，可以把Python的串列當做完美的“多重集”資料結構，

用in可以檢查串列是否包含某個值：

In [55]: 'dwarf' in b_list
Out[55]: True

否定in可以再加一個not：

In [56]: 'dwarf' not in b_list
Out[56]: False

在串列中檢查是否存在某個值遠比字典和集合速度慢，因為Python是線性搜索串列中的值，但在字典和集合中，在同樣的時間內還可以檢查其它項（基于哈希表），

串聯和組合串列

與元組類似，可以用加號將兩個串列串聯起來：

In [57]: [4, None, 'foo'] + [7, 8, (2, 3)]
Out[57]: [4, None, 'foo', 7, 8, (2, 3)]

如果已經定義了一個串列，用extend方法可以追加多個元素：

In [58]: x = [4, None, 'foo']
In [59]: x.extend([7, 8, (2, 3)])
In [60]: x
Out[60]: [4, None, 'foo', 7, 8, (2, 3)]

通過加法將串列串聯的計算量較大，因為要新建一個串列，并且要復制物件，用extend追加元素，尤其是到一個大串列中，更為可取，

everything = []
for chunk in list_of_lists:
 everything.extend(chunk)

要比串聯方法快：

everything = []
for chunk in list_of_lists:
    everything = everything + chunk

排序

你可以用sort函式將一個串列原地排序（不創建新的物件）：

In [61]: a = [7, 2, 5, 1, 3]
In [62]: a.sort()
In [63]: a
Out[63]: [1, 2, 3, 5, 7]

sort有一些選項，有時會很好用，其中之一是二級排序key，可以用這個key進行排序，例如，我們可以按長度對字串進行排序：

In [64]: b = ['saw', 'small', 'He', 'foxes', 'six']
In [65]: b.sort(key=len)
In [66]: b
Out[66]: ['He', 'saw', 'six', 'small', 'foxes']

稍后，我們會學習sorted函式，它可以產生一個排好序的序列副本，

二分搜索和維護已排序的串列

bisect模塊支持二分查找，和向已排序的串列插入值，

  • bisect.bisect可以找到插入值后仍保證排序的位置，
  • bisect.insort是向這個位置插入值：
In [67]: import bisect
In [68]: c = [1, 2, 2, 2, 3, 4, 7]
In [69]: bisect.bisect(c, 2)
Out[69]: 4
In [70]: bisect.bisect(c, 5)
Out[70]: 6
In [71]: bisect.insort(c, 6)
In [72]: c
Out[72]: [1, 2, 2, 2, 3, 4, 6, 7]
注意：bisect模塊不會檢查串列是否已排好序，進行檢查的話會耗費大量計算，因此，對未排序的串列使用bisect不會產生錯誤，但結果不一定正確，

切片

用切邊可以選取大多數序列型別的一部分，切片的基本形式是在方括號中使用start:stop：

In [73]: seq = [7, 2, 3, 7, 5, 6, 0, 1]
In [74]: seq[1:5]
Out[74]: [2, 3, 7, 5]

切片也可以被序列賦值：

In [75]: seq[3:4] = [6, 3]
In [76]: seq
Out[76]: [7, 2, 3, 6, 3, 5, 6, 0, 1]

切片的起始元素是包括的，不包含結束元素，因此，結果中包含的元素個數是stop - start，start或stop都可以被省略，省略之后，分別默認序列的開頭和結尾，負數表明從后向前切片，

展示了正整數和負整數的切片，

在第二個冒號后面使用step，可以隔一個取一個元素：

In [81]: seq[::2]
Out[81]: [7, 3, 3, 6, 1]

一個聰明的方法是使用-1，它可以將串列或元組顛倒過來：

In [82]: seq[::-1]
Out[82]: [1, 0, 6, 5, 3, 6, 3, 2, 7]

序列函式

enumerate函式

迭代一個序列時，你可能想跟蹤當前項的序號，手動的方法可能是下面這樣：

i = 0
for value in collection:
 # do something with value
 i += 1

Python內建了一個enumerate函式，可以回傳(i, value)元組序列：

for i, value in enumerate(collection):
 # do something with value

當你索引資料時，使用enumerate的一個好方法是計算序列（唯一的）dict映射到位置的值：

In [83]: some_list = ['foo', 'bar', 'baz']
In [84]: mapping = {}
# 同時列出序號和資料內容
In [85]: for i, v in enumerate(some_list):
 ....:     mapping[v] = i
In [86]: mapping
Out[86]: {'bar': 1, 'baz': 2, 'foo': 0}

sorted函式

sorted函式可以從任意序列的元素回傳一個新的排好序的串列：

In [87]: sorted([7, 1, 2, 6, 0, 3, 2])
Out[87]: [0, 1, 2, 2, 3, 6, 7]
In [88]: sorted('horse race')
Out[88]: [' ', 'a', 'c', 'e', 'e', 'h', 'o', 'r', 'r', 's']

sorted函式可以接受和sort相同的引數，

zip函式

zip可以將多個串列、元組或其它序列成對組合成一個元組串列：

In [89]: seq1 = ['foo', 'bar', 'baz']
In [90]: seq2 = ['one', 'two', 'three']
In [91]: zipped = zip(seq1, seq2)
In [92]: list(zipped)
Out[92]: [('foo', 'one'), ('bar', 'two'), ('baz', 'three')]

zip可以處理任意多的序列，元素的個數取決于最短的序列：

In [93]: seq3 = [False, True]
In [94]: list(zip(seq1, seq2, seq3))
Out[94]: [('foo', 'one', False), ('bar', 'two', True)]

zip的常見用法之一是同時迭代多個序列，可能結合enumerate使用：

In [95]: for i, (a, b) in enumerate(zip(seq1, seq2)):
 ....: print('{0}: {1}, {2}'.format(i, a, b))
 ....:
0: foo, one
1: bar, two
2: baz, three

給出一個“被壓縮的”序列，zip可以被用來解壓序列，也可以當作把行的串列轉換為列的串列，這個方法看起來有點神奇：

In [96]: pitchers = [('Nolan', 'Ryan'), ('Roger', 'Clemens'),

....: ('Schilling', 'Curt')]

In [97]: first_names, last_names = zip(*pitchers)

In [98]: first_names

Out[98]: ('Nolan', 'Roger', 'Schilling')

In [99]: last_names

Out[99]: ('Ryan', 'Clemens', 'Curt')

reversed函式

reversed可以從后向前迭代一個序列：

In [100]: list(reversed(range(10)))
Out[100]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

要記住reversed是一個生成器（后面詳細介紹），只有物體化（即串列或for回圈）之后才能創建翻轉的序列，

字典

創建字典

字典更為常見的名字是哈希映射或關聯陣列，它是鍵值對的大小可變集合，鍵和值都是Python物件，創建字典的方法之一是使用尖括號，用冒號分隔鍵和值：

In [101]: empty_dict = {}
In [102]: d1 = {'a' : 'some value', 'b' : [1, 2, 3, 4]}
In [103]: d1
Out[103]: {'a': 'some value', 'b': [1, 2, 3, 4]}

訪問字典

你可以像訪問串列或元組中的元素一樣，訪問、插入或設定字典中的元素：

In [104]: d1[7] = 'an integer'
In [105]: d1
Out[105]: {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}
In [106]: d1['b']
Out[106]: [1, 2, 3, 4]

你可以用檢查串列和元組是否包含某個值的方法，檢查字典中是否包含某個鍵：

In [107]: 'b' in d1
Out[107]: True

洗掉

可以用del關鍵字或pop方法（回傳值的同時洗掉鍵）洗掉值：

In [111]: d1
Out[111]: 
{'a': 'some value',
 'b': [1, 2, 3, 4],
 7: 'an integer',
 5: 'some value',
 'dummy': 'another value'}
In [112]: del d1[5]
In [114]: ret = d1.pop('dummy')
In [115]: ret
Out[115]: 'another value'
In [116]: d1
Out[116]: {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}

keys 和 values

keys 和 values 是字典的鍵和值的迭代器方法，雖然鍵值對沒有順序，這兩個方法可以用相同的順序輸出鍵和值：

In [117]: list(d1.keys())
Out[117]: ['a', 'b', 7]
In [118]: list(d1.values())
Out[118]: ['some value', [1, 2, 3, 4], 'an integer']

融合

用update方法可以將一個字典與另一個融合：

In [119]: d1.update({'b' : 'foo', 'c' : 12})
In [120]: d1
Out[120]: {'a': 'some value', 'b': 'foo', 7: 'an integer', 'c': 12}

update方法是原地改變字典，因此任何傳遞給update的鍵的舊的值都會被舍棄，

用序列創建字典

常常，你可能想將兩個序列配對組合成字典，下面是一種寫法：

mapping = {}
for key, value in zip(key_list, value_list):
    mapping[key] = value

因為字典本質上是2元元組的集合，dict可以接受2元元組的串列：

In [121]: mapping = dict(zip(range(5), reversed(range(5))))
In [122]: mapping
Out[122]: {0: 4, 1: 3, 2: 2, 3: 1, 4: 0}

后面會談到dict comprehensions，另一種構建字典的優雅方式，

默認值

下面的邏輯很常見：

if key in some_dict:
    value = some_dict[key]
else:
    value = default_value

因此，dict的方法get和pop可以取默認值進行回傳，上面的if-else陳述句可以簡寫成下面：

value = https://www.cnblogs.com/huaweiyun/p/some_dict.get(key, default_value)

get默認會回傳None，如果不存在鍵，pop會拋出一個例外，關于設定值，常見的情況是在字典的值是屬于其它集合，如串列，例如，你可以通過首字母，將一個串列中的單詞分類：

In [123]: words = ['apple', 'bat', 'bar', 'atom', 'book']
In [124]: by_letter = {}
In [125]: for word in words:
 # 取首字母
 .....:     letter = word[0]
 .....: if letter not in by_letter:
 # 沒有該首字母，以該首字母為鍵，word為值
 .....: by_letter[letter] = [word]
 .....: else:
 # 直接添加
 .....: by_letter[letter].append(word)
 .....:
In [126]: by_letter
Out[126]: {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']}

setdefault方法就正是干這個的，前面的for回圈可以改寫為：

for word in words:
    letter = word[0]
 by_letter.setdefault(letter, []).append(word)

collections模塊有一個很有用的類，defaultdict，它可以進一步簡化上面，傳遞型別或函式以生成每個位置的默認值：

from collections import defaultdict
by_letter = defaultdict(list)
for word in words:
 by_letter[word[0]].append(word)

有效的鍵型別

字典的值可以是任意Python物件，而鍵通常是不可變的標量型別（整數、浮點型、字串）或元組（元組中的物件必須是不可變的），這被稱為“可哈希性”，可以用hash函式檢測一個物件是否是可哈希的（可被用作字典的鍵）：

In [127]: hash('string')
Out[127]: 5023931463650008331
In [128]: hash((1, 2, (2, 3)))
Out[128]: 1097636502276347782
In [129]: hash((1, 2, [2, 3])) # fails because lists are mutable
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-129-800cd14ba8be> in <module>()
----> 1 hash((1, 2, [2, 3])) # fails because lists are mutable
TypeError: unhashable type: 'list'

要用串列當做鍵，一種方法是將串列轉化為元組，只要內部元素可以被哈希，它也就可以被哈希：

In [130]: d = {}
In [131]: d[tuple([1, 2, 3])] = 5
In [132]: d
Out[132]: {(1, 2, 3): 5}

集合

創建

集合是無序的不可重復的元素的集合，你可以把它當做字典，但是只有鍵沒有值，可以用兩種方式創建集合：通過set函式或使用尖括號set陳述句：

In [133]: set([2, 2, 2, 1, 3, 3])
Out[133]: {1, 2, 3}
In [134]: {2, 2, 2, 1, 3, 3}
Out[134]: {1, 2, 3}

集合支持合并、交集、差分和對稱差等數學集合運算，考慮兩個示例集合：

In [135]: a = {1, 2, 3, 4, 5}
In [136]: b = {3, 4, 5, 6, 7, 8}

合并 union 或者 |

合并是取兩個集合中不重復的元素，可以用union方法，或者|運算子：

In [137]: a.union(b)
Out[137]: {1, 2, 3, 4, 5, 6, 7, 8}
In [138]: a | b
Out[138]: {1, 2, 3, 4, 5, 6, 7, 8}

交集 intersection 或者 &

交集的元素包含在兩個集合中，可以用intersection或&運算子：

In [139]: a.intersection(b)
Out[139]: {3, 4, 5}
In [140]: a & b
Out[140]: {3, 4, 5}

表3-1列出了常用的集合方法，

所有邏輯集合操作都有另外的原地實作方法，可以直接用結果替代集合的內容，對于大的集合，這么做效率更高：

In [141]: c = a.copy()
In [142]: c |= b
In [143]: c
Out[143]: {1, 2, 3, 4, 5, 6, 7, 8}
In [144]: d = a.copy()
In [145]: d &= b
In [146]: d
Out[146]: {3, 4, 5}

與字典類似，集合元素通常都是不可變的，要獲得類似串列的元素，必須轉換成元組：

In [147]: my_data = https://www.cnblogs.com/huaweiyun/p/[1, 2, 3, 4]
In [148]: my_set = {tuple(my_data)}
In [149]: my_set
Out[149]: {(1, 2, 3, 4)}

superset 和 subset

你還可以檢測一個集合是否是另一個集合的子集或父集：

In [150]: a_set = {1, 2, 3, 4, 5}
In [151]: {1, 2, 3}.issubset(a_set)
Out[151]: True
In [152]: a_set.issuperset({1, 2, 3})
Out[152]: True

集合的內容相同時，集合才對等：

In [153]: {1, 2, 3} == {3, 2, 1}
Out[153]: True

串列、集合和字典推導式

串列推導式！

串列推導式是Python最受喜愛的特性之一，它允許用戶方便的從一個集合過濾元素，形成串列，在傳遞引數的程序中還可以修改元素，形式如下：

[expr for val in collection if condition]

它等同于下面的for回圈;

result = []
for val in collection:
 if condition:
 result.append(expr)

filter條件可以被忽略，只留下運算式就行，例如，給定一個字串串列，我們可以過濾出長度在2及以下的字串，并將其轉換成大寫：

In [154]: strings = ['a', 'as', 'bat', 'car', 'dove', 'python']
In [155]: [x.upper() for x in strings if len(x) > 2]
Out[155]: ['BAT', 'CAR', 'DOVE', 'PYTHON']

字典的推導式 ！

用相似的方法，還可以推導集合和字典，字典的推導式如下所示：

dict_comp = {key-expr : value-expr for value in collection if condition}

集合的推導式！

集合的推導式與串列很像，只不過用的是尖括號：

set_comp = {expr for value in collection if condition}

與串列推導式類似，集合與字典的推導也很方便，而且使代碼的讀寫都很容易，來看前面的字串串列，假如我們只想要字串的長度，用集合推導式的方法非常方便：

In [156]: unique_lengths = {len(x) for x in strings}
In [157]: unique_lengths
Out[157]: {1, 2, 3, 4, 6}

map函式可以進一步簡化：

In [158]: set(map(len, strings)) # 妙極
Out[158]: {1, 2, 3, 4, 6}

作為一個字典推導式的例子，我們可以創建一個字串的查找映射表以確定它在串列中的位置：

In [159]: loc_mapping = {val : index for index, val in enumerate(strings)}
In [160]: loc_mapping
Out[160]: {'a': 0, 'as': 1, 'bat': 2, 'car': 3, 'dove': 4, 'python': 5}

嵌套串列推導式

假設我們有一個包含串列的串列，包含了一些英文名和西班牙名：

In [161]: all_data = https://www.cnblogs.com/huaweiyun/p/[['John', 'Emily', 'Michael', 'Mary', 'Steven'],
 .....: ['Maria', 'Juan', 'Javier', 'Natalia', 'Pilar']]

你可能是從一些檔案得到的這些名字，然后想按照語言進行分類，現在假設我們想用一個串列包含所有的名字，這些名字中包含兩個或更多的e，可以用for回圈來做：

names_of_interest = []
for names in all_data:
 enough_es = [name for name in names if name.count('e') >= 2]
 names_of_interest.extend(enough_es)

可以用嵌套串列推導式的方法，將這些寫在一起，如下所示：

In [162]: result = [name for names in all_data for name in names
 .....: if name.count('e') >= 2]
In [163]: result
Out[163]: ['Steven']

嵌套串列推導式看起來有些復雜，串列推導式的for部分是根據嵌套的順序，過濾條件還是放在最后，下面是另一個例子，我們將一個整數元組的串列扁平化成了一個整數串列：

In [164]: some_tuples = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
In [165]: flattened = [x for tup in some_tuples for x in tup]
In [166]: flattened
Out[166]: [1, 2, 3, 4, 5, 6, 7, 8, 9]

記住，for運算式的順序是與嵌套for回圈的順序一樣（而不是串列推導式的順序）：

flattened = []
for tup in some_tuples:
 for x in tup:
 flattened.append(x)

你可以有任意多級別的嵌套，但是如果你有兩三個以上的嵌套，你就應該考慮下代碼可讀性的問題了，分辨串列推導式的串列推導式中的語法也是很重要的：

In [167]: [[x for x in tup] for tup in some_tuples]
Out[167]: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

這段代碼產生了一個串列的串列，而不是扁平化的只包含元素的串列，

 

點擊關注，第一時間了解華為云新鮮技術~

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

標籤：Python

上一篇：Spring 注解

下一篇：返回列表

標籤雲
其他(158614) Python(38119) JavaScript(25405) Java(18024) C(15222) 區塊鏈(8262) C＃(7972) AI(7469) 爪哇(7425) MySQL(7171) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5871) 数组(5741) R(5409) Linux(5336) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4567) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2432) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1965) Web開發(1951) HtmlCss(1932) python-3.x(1918) 弹簧靴(1913) C++(1912) xml(1889) PostgreSQL(1874) .NETCore(1857) 谷歌表格(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
最新发布
  • 幾種常見的Python資料結構

    摘要：本文主要為大家講解在Python開發中常見的幾種資料結構。 本文分享自華為云社區《Python的常見資料結構》，作者： timerring 。 資料結構和序列 元組 元組是一個固定長度，不可改變的Python序列物件。創建元組的最簡單方式，是用逗號分隔一列值： In [1]: tup = 4, ......

    uj5u.com 2023-05-09 07:22:56 more
  • Spring 注解

    @SpringBootApplication 申明讓spring boot自動給程式進行必要的配置，這個配置等同于： @Configuration ，@EnableAutoConfiguration 和 @ComponentScan 三個配置。 @RequestMapping 提供路由資訊，負責UR ......

    uj5u.com 2023-05-09 07:19:04 more
  • ChatGPT 對接微信公眾號技術方案實作！

    如假期前小傅哥的計劃一樣，這個假期開啟了新的技術專案《ChatGPT 微服務應用體系構建》教程；從搭建環境、開發chatgpt-sdk-java、對接公眾號、封裝api，直至假期最后一天，完成了微信公眾號的對接，可以與 ChatGPT 對話聊天啦！。 ......

    uj5u.com 2023-05-08 08:35:31 more
  • ChatGPT 對接微信公眾號技術方案實作！

    如假期前小傅哥的計劃一樣，這個假期開啟了新的技術專案《ChatGPT 微服務應用體系構建》教程；從搭建環境、開發chatgpt-sdk-java、對接公眾號、封裝api，直至假期最后一天，完成了微信公眾號的對接，可以與 ChatGPT 對話聊天啦！。 ......

    uj5u.com 2023-05-08 08:34:29 more
  • Django筆記三十六之單元測驗匯總介紹

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記三十六之單元測驗匯總介紹 Django 的單元測驗使用了 Python 的標準庫：unittest。 在我們創建的每一個 application 下面都有一個 tests.py 檔案，我們通過繼承 django.test.TestCase ......

    uj5u.com 2023-05-07 07:50:37 more
  • SpringBoot 自動掃描第三方包及spring.factories失效的問題

    為什么會找不到 Spring 依賴注入 就是要讓spring找到要注入的類 并且識別到了 @Component、@Service 等注解。 1. 當在開發的第三方包里寫明了 @Component、@Service 等等 2. 引入了包，不論第三方庫的引入，還是本地jar。總之是要引入到工程的 這時候 ......

    uj5u.com 2023-05-07 07:28:20 more
  • 一套前后臺全部開源的H5商城送給大家

    博主給大家推薦一套全部開源的H5電商專案waynboot-mall。由博主在2020年開發至今，已有三年之久。那時候網上很多的H5商城專案都是半開源版本，要么沒有H5前端代碼，要么需要加群咨詢，屬實惡心。于是博主決定自己開發一套完整的移動端H5商城，包含一個管理后臺、一個前臺H5商城、一套后端介面。 ......

    uj5u.com 2023-05-06 07:42:26 more
  • go測驗庫之apitest

    前言 使用go語言做開發差不多快一年了，主要用來寫后端Web服務，從一開始吐槽他的結構體，比如創建個復雜的JSON格式資料，那是相當的痛苦。還有 err 處理寫的巨麻煩。 當然，go 也有爽的地方，創建個線協程簡直太簡單了。 到后來慢慢接受，覺得效率還行，因為是靜態強型別語言，在修改完專案代碼之后， ......

    uj5u.com 2023-05-06 07:41:31 more
  • Java8 Stream流的合并

    最近的需求里有這樣一個場景，要校驗一個集合中每個物件的多個Id的有效性。比如一個Customer物件，有3個Id：id1，id2，id3，要把這些Id全部取出來，然后去資料庫里查詢它是否存在。 @Data @AllArgsConstructor public class Customer { pri ......

    uj5u.com 2023-05-06 07:41:25 more
  • 【Visual Leak Detector】在 VS 高版本中使用 VLD

    說明 使用 VLD 記憶體泄漏檢測工具輔助開發時整理的學習筆記。 本篇介紹如何在 VS 高版本中使用 vld2.5.1。同系列文章目錄可見 《記憶體泄漏檢測工具》目錄 1. 使用前的準備 參考本人另一篇博客 安裝 Visual Leak Detector 下載 vld-2.5.1-setup.exe 并 ......

    uj5u.com 2023-05-06 07:41:21 more

Copyright © 2010-2020 有解無憂