主頁 > 後端開發 > python基礎入門語法和變數型別（二）

python基礎入門語法和變數型別（二）

2020-09-20 18:31:42 後端開發

串列

串列是 Python 中使用最頻繁的資料型別，它可以完成大多數集合類的資料結構實作，可以包含不同型別的元素，包括數字、字串，甚至串列（也就是所謂的嵌套），

和字串一樣，可以通過索引值或者切片(截取)進行訪問元素，索引也是從 0 開始，而如果是倒序，則是從 -1 開始，串列截取的示意圖如下所示：

 

另外，還可以添加第三個引數作為步長：

 

同樣，串列也有很多內置的方法，這里介紹一些常見的方法：

  • len(list)：回傳串列的長度
  • append(obj) / insert(index, obj) / extend(seq)：增加元素的幾個方法
  • pop() / remove(obj) / del list[index] / clear()：洗掉元素
  • reverse() / reversed：反轉串列
  • sort() / sorted(list)：對串列排序，注意前者會修改串列內容，后者回傳一個新的串列物件，不改變原始串列
  • index()：查找給定元素第一次出現的索引位置

初始化串列的代碼示例如下：

# 創建空串列，兩種方法

list1 = list()

list2 = []# 初始化帶有資料

list3 = [1, 2, 3]

list4 = ['a', 2, 'nb', [1, 3, 4]]

 

print('list1:', list1)

print('list2:', list2)

print('list3:', list3)

print('list4:', list4)

print('len(list4): ', len(list4))  

添加元素的代碼示例如下：

# 末尾添加元素

list1.append('abc')

print('list1:', list1)# 末尾添加另一個串列，并合并為一個串列

list1.extend(list3)

print('list1.extend(list3), list1:', list1)

list1.extend((1, 3))

print('list1.extend((1,3)), list1:', list1)# 通過 += 添加元素

list2 += [1, 2, 3]

print('list2:', list2)

list2 += list4

print('list2:', list2)# 在指定位置添加元素,原始位置元素右移一位

list3.insert(0, 'a')

print('list3:', list3)# 末尾位置添加，原來末尾元素依然保持在末尾

list3.insert(-1, 'b')

print('list3:', list3)  

洗掉元素的代碼示例如下：

# del 洗掉指定位置元素del list3[-1]

print('del list3[-1], list3:', list3)# pop 洗掉元素

pop_el = list3.pop()

print('list3:', list3)

print('pop element:', pop_el)# pop 洗掉指定位置元素

pop_el2 = list3.pop(0)

print('list3:', list3)

print('pop element:', pop_el2)# remove 根據值洗掉元素

list3.remove(1)

print('list3:', list3)# clear 清空串列

list3.clear()

print('clear list3:', list3)  

查找元素和修改、訪問元素的代碼示例如下：

# index 根據數值查詢索引

ind = list1.index(3)

print('list1.index(3)，index=', ind)# 訪問串列第一個元素

print('list1[0]: ', list1[0])# 訪問串列最后一個元素

print('list1[-1]: ', list1[-1])# 訪問第一個到第三個元素

print('list1[:3]: ', list1[:3])# 訪問第一個到第三個元素,步長為2

print('list1[:3:2]: ', list1[:3:2])# 復制串列

new_list = list1[:]

print('copy list1, new_list:', new_list)  

排序的代碼示例如下：

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

print('list5:', list5)# use sorted

list6 = sorted(list5)

print('list6=sorted(list5), list5={}, list6={}'.format(list5, list6))# use list.sort()

list5.sort()

print('list5.sort(), list5: ', list5)  

sorted() 都不會改變串列本身的順序，只是對串列臨時排序，并回傳一個新的串列物件；

相反，串列本身的 sort() 會永久性改變串列本身的順序，

另外，如果串列元素不是單純的數值型別，如整數或者浮點數，而是字串、串列、字典或者元組，那么還可以自定義排序規則，這也就是定義中最后兩行，例子如下：

# 串列元素也是串列

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

list9 = sorted(list8)

print('list9 = sorted(list8), list9=', list9)# sorted by the second element

list10 = sorted(list8, key=lambda x: x[1])

print('list10 = sorted(list8, key=lambda x:x[1]), list10=', list10)

list11 = sorted(list8, key=lambda x: (x[1], x[0]))

print('list11 = sorted(list8, key=lambda x:(x[1],x[0])), list11=', list11)# 串列元素是字串

list_str = ['abc', 'pat', 'cda', 'nba']

list_str_1 = sorted(list_str)

print('list_str_1 = sorted(list_str), list_str_1=', list_str_1)# 根據第二個元素排列

list_str_2 = sorted(list_str, key=lambda x: x[1])

print('list_str_2 = sorted(list_str, key=lambda x: x[1]), list_str_2=', list_str_2)# 先根據第三個元素，再根據第一個元素排列

list_str_3 = sorted(list_str, key=lambda x: (x[2], x[0]))

print('list_str_3 = sorted(list_str, key=lambda x: (x[2], x[0])), list_str_3=', list_str_3)  

反轉串列的代碼示例如下：

# 反轉串列

list5.reverse()

print('list5.reverse(), list5: ', list5)

list7 = reversed(list5)

print('list7=reversed(list5), list5={}, list7={}'.format(list5, list7))#for val in list7:#    print(val)# 注意不能同時兩次

list7_val = [val for val in list7]

print('采用串列推導式, list7_val=', list7_val)

list8 = list5[::-1]

print('list5 = {}\nlist_reversed = list5[::-1], list_reversed = {}'.format(list5, list_reversed))  

reverse() 方法會永久改變串列本身，而 reversed() 不會改變串列物件，它回傳的是一個迭代物件，如例子輸出的 <list_reverseiterator object at 0x000001D0A17C5550> , 要獲取其排序后的結果，需要通過 for 回圈，或者串列推導式，但需要注意，它僅僅在第一次遍歷時候回傳數值，

以及，一個小小的技巧，利用切片實作反轉，即 <list> = <list>[::-1]，

元組

元組和串列比較相似，不同之處是元組不能修改，然后元組是寫在小括號 () 里的，

元組也可以包含不同的元素型別，簡單的代碼示例如下：

t1 = tuple()

t2 = ()

t3 = (1, 2, '2', [1, 2], 5)# 創建一個元素的元祖

t4 = (7, )

t5 = (2)

print('創建兩個空元組：t1={}, t2={}'.format(t1, t2))

print('包含不同元素型別的元組：t3={}'.format(t3))

print('包含一個元素的元祖: t4=(7, )={}, t5=(2)={}'.format(t4, t5))

print('type(t4)={}, type(t5)={}'.format(type(t4), type(t5)))

print('輸出元組的第一個元素：{}'.format(t3[0]))

print('輸出元組的第二個到第四個元素：{}'.format(t3[1:4]))

print('輸出元祖的最后一個元素: {}'.format(t3[-1]))

print('輸出元祖兩次: {}'.format(t3 * 2))

print('連接元祖: {}'.format(t3 + t4))  

元祖和字串也是類似，索引從 0 開始，-1 是末尾開始的位置，可以將字串看作一種特殊的元組，

此外，從上述代碼示例可以看到有個特殊的例子，創建一個元素的時候，必須在元素后面添加逗號，即如下所示:

tup1 = (2,) # 輸出為 (2,)

tup2 = (2)  # 輸出是 2

print('type(tup1)={}'.format(type(tup1))) # 輸出是 <class 'tuple'>

print('type(tup2)={}'.format(type(tup2))) # 輸出是 <class 'int'>  

還可以創建一個二維元組，代碼例子如下：

# 創建一個二維元組

tups = (1, 3, 4), ('1', 'abc')

print('二維元組: {}'.format(tups)) # 二維元組: ((1, 3, 4), ('1', 'abc'))  

然后對于函式的回傳值，如果回傳多個，實際上就是回傳一個元組，代碼例子如下：

def print_tup():

    return 1, '2'

 

 

res = print_tup()

print('type(res)={}, res={}'.format(type(res), res)) # type(res)=<class 'tuple'>, res=(1, '2')  

元組不可修改，但如果元素可修改，那可以修改該元素內容，代碼例子如下所示：

tup11 = (1, [1, 3], '2')

print('tup1={}'.format(tup11)) # tup1=(1, [1, 3], '2')

tup11[1].append('123')

print('修改tup11[1]后，tup11={}'.format(tup11)) # 修改tup11[1]后，tup11=(1, [1, 3, '123'], '2')  

因為元組不可修改，所以僅有以下兩個方法：

  • count(): 計算某個元素出現的次數
  • index(): 尋找某個元素第一次出現的索引位置

代碼例子：

# count()

print('tup11.count(1)={}'.format(tup11.count(1)))# index()

print('tup11.index(\'2\')={}'.format(tup11.index('2')))  

字典

字典也是 Python 中非常常用的資料型別，具有以下特點：

  • 它是一種映射型別，用 {} 標識，是無序的 鍵(key): 值(value) 的集合；
  • 鍵(key) 必須使用不可變型別；
  • 同一個字典中，鍵必須是唯一的；

創建字典的代碼示例如下，總共有三種方法：

# {} 形式

dic1 = {'name': 'python', 'age': 20}# 內置方法 dict()

dic2 = dict(name='p', age=3)# 字典推導式

dic3 = {x: x**2 for x in {2, 4, 6}}

print('dic1={}'.format(dic1)) # dic1={'age': 20, 'name': 'python'}

print('dic2={}'.format(dic2)) # dic2={'age': 3, 'name': 'p'}

print('dic3={}'.format(dic3)) # dic3={2: 4, 4: 16, 6: 36}  

常見的三個內置方法，keys(), values(), items() 分別表示鍵、值、對，例子如下：

print('keys()方法，dic1.keys()={}'.format(dic1.keys()))print('values()方法, dic1.values()={}'.format(dic1.values()))print('items()方法, dic1.items()={}'.format(dic1.items()))  

其他對字典的操作，包括增刪查改，如下所示：

# 修改和訪問

dic1['age'] = 33

dic1.setdefault('sex', 'male')

print('dic1={}'.format(dic1))# get() 訪問某個鍵

print('dic1.get(\'age\', 11)={}'.format(dic1.get('age', 11)))

print('訪問某個不存在的鍵，dic1.get(\'score\', 100)={}'.format(dic1.get('score', 100)))# 洗掉del dic1['sex']

print('del dic1[\'sex\'], dic1={}'.format(dic1))

dic1.pop('age')

print('dic1.pop(\'age\'), dic1={}'.format(dic1))# 清空

dic1.clear()

print('dic1.clear(), dic1={}'.format(dic1))# 合并兩個字典

print('合并 dic2 和 dic3 前, dic2={}, dic3={}'.format(dic2, dic3))

dic2.update(dic3)

print('合并后，dic2={}'.format(dic2))

# 遍歷字典

dic4 = {'a': 1, 'b': 2}for key, val in dic4.items():

    print('{}: {}'.format(key, val))# 不需要采用 keys()for key in dic4:

    print('{}: {}'.format(key, dic4[key]))  

最后，因為字典的鍵必須是不可改變的資料型別，那么如何快速判斷一個資料型別是否可以更改呢？有以下兩種方法：

  • id()：判斷變數更改前后的 id，如果一樣表示可以更改，不一樣表示不可更改，
  • hash()：如果不報錯，表示可以被哈希，就表示不可更改；否則就是可以更改，

首先看下 id() 方法，在一個整型變數上的使用結果：

i = 2

print('i id value='https://www.cnblogs.com/Mrzhangzong/p/, id(i))

i += 3

print('i id value='https://www.cnblogs.com/Mrzhangzong/p/, id(i))

輸出結果，更改前后 id 是更改了，表明整型變數是不可更改的，

i id value= https://www.cnblogs.com/Mrzhangzong/p/1758265872

i id value= https://www.cnblogs.com/Mrzhangzong/p/1758265968

然后在串列變數上進行同樣的操作：

l1 = [1, 3]

print('l1 id value='https://www.cnblogs.com/Mrzhangzong/p/, id(l1))

l1.append(4)

print('l1 id value='https://www.cnblogs.com/Mrzhangzong/p/, id(l1))

輸出結果，id 并沒有改變，說明串列是可以更改的，

l1 id value= https://www.cnblogs.com/Mrzhangzong/p/1610679318408

l1 id value= https://www.cnblogs.com/Mrzhangzong/p/1610679318408

然后就是采用 hash() 的代碼例子：

# hash

s = 'abc'

print('s hash value: ', hash(s))

l2 = ['321', 1]

print('l2 hash value: ', hash(l2))   

輸出結果如下，對于字串成功輸出哈希值，而串列則報錯 TypeError: unhashable type: 'list'，這也說明了字串不可更改，而串列可以更改，

s hash value:  1106005493183980421

TypeError: unhashable type: 'list'  

集合

集合是一個無序的不重復元素序列，采用大括號 {} 或者 set() 創建，但空集合必須使用 set() ，因為 {} 創建的是空字典，

創建的代碼示例如下：

# 創建集合

s1 = {'a', 'b', 'c'}

s2 = set()

s3 = set('abc')

print('s1={}'.format(s1)) # s1={'b', 'a', 'c'}

print('s2={}'.format(s2)) # s2=set()

print('s3={}'.format(s3)) # s3={'b', 'a', 'c'}  

注意上述輸出的時候，每次運行順序都可能不同，這是集合的無序性的原因，

利用集合可以去除重復的元素，如下所示：

s4 = set('good')

print('s4={}'.format(s4)) # s4={'g', 'o', 'd'}  

集合也可以進行增加和洗掉元素的操作，代碼如下所示：

# 增加元素，add() 和 update()

s1.add('dd')

print('s1.add(\'dd\'), s1={}'.format(s1)) # s1.add('dd'), s1={'dd', 'b', 'a', 'c'}

s1.update('o')

print('添加一個元素，s1={}'.format(s1)) # 添加一個元素，s1={'dd', 'o', 'b', 'a', 'c'}

s1.update(['n', 1])

print('添加多個元素, s1={}'.format(s1)) # 添加多個元素, s1={1, 'o', 'n', 'a', 'dd', 'b', 'c'}

s1.update([12, 33], {'ab', 'cd'})

print('添加串列和集合, s1={}'.format(s1)) # 添加串列和集合, s1={1, 33, 'o', 'n', 'a', 12, 'ab', 'dd', 'cd', 'b', 'c'}

# 洗掉元素, pop(), remove(), clear()

print('s3={}'.format(s3)) # s3={'b', 'a', 'c'}

s3.pop()

print('隨機洗掉元素, s3={}'.format(s3)) # 隨機洗掉元素, s3={'a', 'c'}

s3.clear()

print('清空所有元素, s3={}'.format(s3)) # 清空所有元素, s3=set()

s1.remove('a')

print('洗掉指定元素,s1={}'.format(s1)) # 洗掉指定元素,s1={1, 33, 'o', 'n', 12, 'ab', 'dd', 'cd', 'b', 'c'}  

此外，還有專門的集合操作，包括求取兩個集合的并集、交集

# 判斷是否子集, issubset()

a = set('abc')

b = set('bc')

c = set('cd')

print('b是否a的子集:', b.issubset(a)) # b是否a的子集: True

print('c是否a的子集:', c.issubset(a)) # c是否a的子集: False

# 并集操作，union() 或者 |

print('a 和 c 的并集:', a.union(c)) # a 和 c 的并集: {'c', 'b', 'a', 'd'}

print('a 和 c 的并集:', a | c) # a 和 c 的并集: {'c', 'b', 'a', 'd'}

# 交集操作，intersection() 或者 &

print('a 和 c 的交集:', a.intersection(c)) # a 和 c 的交集: {'c'}

print('a 和 c 的交集:', a & c) # a 和 c 的交集: {'c'}

# 差集操作，difference() 或者 - ，即只存在一個集合的元素

print('只在a中的元素:', a.difference(c)) # 只在a中的元素:: {'b', 'a'}

print('只在a中的元素:', a - c) # 只在a中的元素:: {'b', 'a'}

# 對稱差集, symmetric_difference() 或者 ^, 求取只存在其中一個集合的所有元素

print('對稱差集:', a.symmetric_difference(c)) # 對稱差集: {'a', 'd', 'b'}

print('對稱差集:', a ^ c) # 對稱差集: {'a', 'd', 'b'}  

資料型別的轉換

有時候我們需要對資料型別進行轉換，比如串列變成字串等，這種轉換一般只需要將資料型別作為函式名即可，下面列舉了這些轉換函式：

int(x, [,base])：將 x 轉換為整數，base 表示進制，默認是十進制

float(x)：將 x 轉換為一個浮點數

complex(x, [,imag])：創建一個復數, imag 表示虛部的數值，默認是0

str(x)：將物件 x 轉換為字串

repr(x)： 將物件 x 轉換為運算式字串

eval(str)： 用來計算在字串中的有效 Python 運算式,并回傳一個物件

tuple(s)： 將序列 s 轉換為一個元組

list(s)： 將序列 s 轉換為一個串列

set(s)：轉換為可變集合

dict(d)： 創建一個字典，d 必須是一個序列 (key,value)元組

frozenset(s)： 轉換為不可變集合

chr(x)：將一個整數轉換為一個字符

ord(x)：將一個字符轉換為它的整數值

hex(x)：將一個整數轉換為一個十六進制字串

oct(x)：將一個整數轉換為一個八進制字串

 

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

標籤：Python

上一篇：Yii2中不同模塊之間的呼叫runAction

下一篇：說說我對 WSGI 的理解

標籤雲
其他(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 有解無憂