Python基礎數據類型：列表【增刪改查】，元組。range

来源:https://www.cnblogs.com/xiaomage666/archive/2019/05/04/10809312.html
-Advertisement-
Play Games

1 知識大綱 列表的初識 列表的索引切片 列表的增刪改查 列表的嵌套 元組的初識（瞭解） 元組的簡單應用（瞭解） range 2 主要內容 1. 列表的初識 why： 字元串： 存儲少量的數據。字元串只能存儲少量的數據，對於大量的數據用字元串操作不方便也不易存儲。 字元串：無論切片還是對其進行任何操 ...


1 知識大綱

  • 列表的初識
  • 列表的索引切片
  • 列表的增刪改查
  • 列表的嵌套
  • 元組的初識（瞭解）
  • 元組的簡單應用（瞭解）
  • range

2 主要內容

1.列表的初識

  • why：

    • 字元串： 存儲少量的數據。字元串只能存儲少量的數據，對於大量的數據用字元串操作不方便也不易存儲。
    • 字元串：無論切片還是對其進行任何操作，獲取的內容全都是str類型。字元串存儲的數據類型太單一，只能是字元串類型。

  • what：list

    • 容器類數據類型：能承載多種數據類型。它可以存儲大量的數據。列表list就屬於容器類的數據類型。
    • 列表相比於字元串，不僅可以儲存不同的數據類型（承載任意數據類型），而且可以儲存大量數據。l1 = [100, 'alex',True,[1, 2, 3]]
    • 列表是有序的，需要存索引相關信息。有索引值，可切片（步長），方便取值。

  • Where:

    ​ 你需要存儲大量的數據，且需要這些數據有序的時候。

    　　制定一些特殊的數據群體：按順序，按規則，自定製設計數據。

2.索引，切片，步長
li = [100, '太白', True, [1, 2, 3]]
# 索引 
列表索引，其在列表中是什麼數據類型，取出來就是什麼數據類型，如數字，字元串，列表...
print(li[0], type(li[0]))  #100 <class 'int'>
print(li[1],type(li[1]))   #太白 <class 'str'>                           
print(li[-1],type(li[-1])) #[1, 2, 3] <class 'list'>

# 切片 （顧頭不顧腚）
列表切片，得到的都是列表類型的數據。

print（li[0:1]） #[100]
print(li[:2])   #[100, '太白']

相關練習題：

li = [1, 3, 2, "a", 4, "b", 5,"c"]
通過對li列表的切片形成新的列表l1,l1 = [1,3,2]
通過對li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
通過對li列表的切片形成新的列表l4,l4 = [3,"a","b"]
通過對li列表的切片形成新的列表l6,l6 = ["b","a",3]

li = [1, 3, 2, "a", 4, "b", 5,"c"]
l1 = li[0:3]
print(l1)
l2 = li[3:6]
print(l2)
l4 = li[1:6:2]
l4 = li[1:-2:2]
print(l4)
l6 = li[-3:0:-2]
print(l6)
3.列表的增刪改查 【重點，記住】
# 列表的創建
# 方式一
l1 = []#創建空列表
l1 = [1, 2, 'Alex',True,[1, 2, 3]]   ###【填入的數據可以是int,bool,str,list類型】

# 方式二
l1 = list()   #創建空列表
print(l1)   #  []
# l1 = list(iterable)  # 可迭代對象
l1 = list('fhdsjkafhsdaf')  ###【填入的數據必須是可迭代的，如str,list。不能是int：TypeError: 'int' object is not iterable，bool：TypeError: 'bool' object is not iterable】
print(l1)    #['f', 'h', 'd', 's', 'j', 'k', 'a', 'f', 'h', 's', 'd', 'a', 'f']

# 方式三：列表推導式 
l1 = [i for i in range(1,5)]
print(l1)  # [1, 2, 3, 4]

# 增刪改查
字元串的常用操作方法,不會對原字元串進行任何操作，都是產生一個新的字元串
 s1 = 'aafsfjgk'
 print(s1)  #aafsfjgk
 print(s1.upper())  #AAFSFJGK
 print(s1)   #aafsfjgk

列表的增刪改查--->改變了原列表
l1 = ['hha','heihei','hehe']
print(l1)  #['hha', 'heihei', 'hehe']
l1.append('hhh')
print(l1)  #['hha', 'heihei', 'hehe', 'hhh']



# 增：

append
#追加，給列表的最後面追加一個元素  
l1 = ['太白', '女神', 'xiao','吳老師', '閆龍']
l1.append('xx')
print(l1.append('xx'))  # 不能列印它   #None
print(l1) 

# 舉例：
l1 = ['太白', '女神', '吳老師', 'xiao', '閆龍']
while 1:
     name = input('請輸入新員工姓名：(Q或者q退出程式)')
     if name.upper() == 'Q': break
     l1.append(name)
 print(l1)

insert 
#插入，在列表的任意位置插入元素  insert(index,object)
l1 = ['太白', '女神', 'xiao','吳老師', '閆龍']
l1.insert(2,'wusir')
print(l1)  #['太白', '女神', 'wusir', 'xiao', '吳老師', '閆龍']

extend 
#迭代著追加，在列表的最後面迭代著追加一組數據【把可迭代對象拆解為最小元素，如字元串'abcd'---->'a','b','c','d'  列表 ['alex', 1, 3] ---> 'alex', 1, 3 】
#extend後面括弧里填入的數據必須是可迭代的，如str，list，不能是int，bool類型，會報錯
l1 = ['太白', '女神', 'xiao', '吳老師', '閆龍']
l1.extend('abcd')   
print(l1)   #['太白', '女神', 'xiao', '吳老師', '閆龍', 'a', 'b', 'c', 'd']

l1 = ['太白', '女神', 'xiao', '吳老師', '閆龍']
l1.extend(['alex',])
print(l1)#['太白', '女神', 'xiao', '吳老師', '閆龍', 'alex']

l1 = ['太白', '女神', 'xiao', '吳老師', '閆龍']
l1.extend(['alex', 1, 3])
print(l1)  #['太白', '女神', 'xiao', '吳老師', '閆龍', 'alex', 1, 3]


# 刪

pop 
#按照索引位置刪除，通過索引刪除列表中對應的元素，該方法有返回值，返回值為刪除的元素   
#pop(index)

l1 = ['太白', '女神', 'xiao', '吳老師', '閆龍']
l1.pop(-2)  # 按照索引刪除 （返回的是刪除的元素）
print(l1.pop(-2))   #  xiao
print(l1)  #['太白', '女神', '閆龍']

l1 = ['太白', '女神', 'xiao', '吳老師', '閆龍']
l1.pop()  # 預設刪除最後一個
print(l1)   #['太白', '女神', 'xiao', '吳老師']


remove  
#指定元素刪除,如果有重名元素，預設刪除從左數第一個
#remove（object）

l1 = [ 'xiao','太白', '女神', 'xiao', '吳老師', '閆龍', 'xiao']
l1.remove('xiao')
print(l1)  #['太白', '女神', 'xiao', '吳老師', '閆龍', 'xiao']
 
    
clear清空 (瞭解)
l1 = [ 'xiao','太白', '女神', 'xiao', '吳老師', '閆龍', 'xiao']
l1.clear()  #清空
print(l1)  #[]


del
#按照索引刪除該元素
 l1 = [ 'xiao','太白', '女神', 'xiao', '吳老師', '閆龍', 'xiao']
 del l1[0]  #['太白', '女神', 'xiao', '吳老師', '閆龍', 'xiao']
 print(l1)

# 按照切片刪除該元素
 l1 = [ 'xiao','太白', '女神', 'xiao', '吳老師', '閆龍', 'xiao']
 del l1[0:2]
 # print(l1)  #['女神', 'xiao', '吳老師', '閆龍', 'xiao']

#按照切片（步長）刪除該元素
 l1 = [ 'xiao','太白', '女神', 'xiao', '吳老師', '閆龍', 'xiao']
 del l1[0:5:2]
 print(l1)  #['太白', 'xiao', '閆龍', 'xiao']


# 改

#按照索引改值
l1 = [ '太白', '女神', 'xiao', '吳老師', '閆龍']
l1[0] = '男神'
print(l1)  #['男神', '女神', 'xiao', '吳老師', '閆龍']

l1 = [ '太白', '女神', 'xiao', '吳老師', '閆龍']
l1[2] = l1[2].upper()
print(l1)  #['太白', '女神', 'XIAO', '吳老師', '閆龍']

#按照切片改（迭代著增加）  【瞭解】 按照切片改，迭代著增加【把可迭代對象分解為最小元素】。按理說刪除幾個，增加幾個。但是此處可以增加多個，刪除元素的個數不用和增加元素的個數對應。
l1 = [ '太白', '女神', 'xiao', '吳老師', '閆龍']
l1[3:] = 'amgnrih'
print(l1)   #['太白', '女神', 'xiao', 'a', 'm', 'g', 'n', 'r', 'i', 'h']

#按照切片步長改（必須一一對應）  【瞭解】必須一 一對應，改幾個位置，寫幾個元素，多了會報錯。
 l1 = [ '太白', '女神', 'xiao', '吳老師', '閆龍']
 l1[::2] = 'amg'
 print(l1)   #['a', '女神', 'm', '吳老師', 'g']
 
 #自
 l1 = ['太白', '女神', 'xiao', '吳老師', '閆龍']
 l1[::2] = [1,2,[3,4]]
 print(l1) #[1, '女神', 2, '吳老師', [3, 4]]

 l1 = [ '太白', '女神', 'xiao', '吳老師', '閆龍']
 l1[::2] = 'abcd'    #必須一一對應，改幾個位置，寫幾個元素，多了會報錯。
 print(l1)   #報錯



# 查：切片去查，或者迴圈去查。  索引，切片（步長）
l1 = [ '太白', '女神', 'xiao', '吳老師', '閆龍']
for i in l1:
     print(i)
 

迴圈列表，改變列表大小的問題
註意：在迴圈一個列表時的過程中，如果你要改變列表的大小（增加值，或者刪除值），那麼結果很可能會出錯或者報錯。因為某些元素的原索引值會改變
#應用實例：請把索引為奇數對應的元素刪除 l1 = [11, 22, 33, 44, 55]  l1可以為任意一個列表，元素個數不定
    方法：直接刪除  倒序刪除 思維置換
#自己編寫
#方法1：直接刪除  按照切片步長刪除
l1 = [11, 22, 33, 44, 55]
del l1[1::2]
print(l1)

#方法2：倒序刪除
#從後往前倒著刪除，不會改變前面元素的序號。分析知道：
# 如果列表中的元素個數為奇數n，要刪除索引號為奇數（正奇數1,3,5,...）的元素，倒著刪除，
# 每次刪除一個元素，要從-2開始刪除，刪除後下一次要刪除元素的索引號變為-3，再下一次變為-4，直到-(n+1)/2,這個數必須為整數int類型
# 因為range顧頭不顧腚，所以其範圍要多一位，即-(int((n+1)/2)+1)
# 如果列表中的元素個數為偶數n，要刪除索引號為奇數（正奇數1,3,5,...）的元素，倒著刪除，
# 每次刪除一個元素，要從-1開始刪除，刪除後下一次要刪除元素的索引號變為-2，再下一次變為-3，直到-n/2,這個數必須為整數int類型，
# 可以用-n//2,取一個負整數。因為range顧頭不顧腚，所以其範圍要多一位，即-(n//2+1)

l1 = [11, 22, 33, 44, 55]
if len(l1) % 2 == 1:
    for i in range(-2,-(int((len(l1) + 1)/2)+1),-1):
        l1.pop(i)
elif len(l1) % 2 == 0:
    for i in range(-1,-((len(l1) // 2)+1),-1):
        del l1[i]   #同l1.pop(i)
print(l1)

#方法3：思維置換
l1 = [11, 22, 33, 44, 55]
for i in range(0,len(l1)):
    if i % 2 == 1:
        l1[i] = ' '  #將所有索引號為奇數的元素修改為同一個元素，如空格' '
num = l1.count(' ')  #統計列表中空格的個數，決定了刪除的次數
for i in range(0,num):
    l1.remove(' ')   #因為remove按指定元素刪除,如果有重名元素，預設刪除從左數第一個，所以要刪除多次
print(l1)  #[11, 33, 55]

#################################################################
補充操作方法：

count（數）
#（方法統計某個元素在列表中出現的次數）。
a = ["q","w","q","r","t","y"]
print(a.count("q"))

index  註意：是某個值‘第一個’匹配項的索引
#（方法用於從列表中找出某個值第一個匹配項的索引位置）
a = ["q","w","r","t","y"]
print(a.index("r"))

########################註意############
#####1.
 li = ["TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc","TaiBai "]
 for i in li:
     j = li.index(i)  #從列表中找出某個值"第一個"匹配項的索引位,註意是第一個
     print(j)
#結果：
# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 0


#####2.
li = ["TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc","TaiBai "]
for i in li:
    j = li.index(i)  #從列表中找出某個值"第一個"匹配項的索引位,註意是第一個
    i = i.strip()    #將i兩邊空白去掉，再賦值給i,此時列表內的對應的元素不會修改
    li[j] = i       #對比發現，按照索引修改列表值的時候，重覆出現元素的索引位改變成7了，不是上邊的0了。此時列表內對應的元素才會修改成功
    print(j)
print（li）   #['TaiBai', 'alexC', 'AbC', 'egon', 'riTiAn', 'WuSir', 'aqc', 'TaiBai']   
# 結果：
# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 7
###############繼續測試---->
個人總結：單純查看j = li.index(i)的值得時候，得到的是列表中某個值"第一個"匹配項的索引位。但是，通過索引修改列表內某個值，即li[j] ='要修改成的值'時，j的索引值就是其實際索引位。

 li = ["TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc","TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc",]
 for i in li:
     j = li.index(i)  #從列表中找出某個值"第一個"匹配項的索引位,註意是第一個
     print(j)# 0 1 2 3 4 5 6 0 1 2 3 4 5 6
 print(li)  #['TaiBai ', 'alexC', 'AbC ', 'egon', ' riTiAn', 'WuSir', ' aqc', 'TaiBai ', 'alexC', 'AbC ', 'egon', ' riTiAn', 'WuSir', ' aqc']

 li = ["TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc","TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc",]
 for i in li:
     j = li.index(i)  #從列表中找出某個值"第一個"匹配項的索引位,註意是第一個
     i = i.strip()
     li[j] = i
     print(j)# 0 1 2 3 4 5 6 7 1 9 3 11 5 13
 print(li)#['TaiBai', 'alexC', 'AbC', 'egon', 'riTiAn', 'WuSir', 'aqc', 'TaiBai', 'alexC', 'AbC', 'egon', 'riTiAn', 'WuSir', 'aqc']

#########################


sort 
#方法用於在原位置對列表進行排序。
a = [2,1,3,4,5]
a.sort()# 他沒有返回值，所以只能列印a
print(a)  #[1, 2, 3, 4, 5]

#測試1
a = ['b','d','c','a','z','w']  #列表中的元素全部為同一個類型的，如int或str，才可用sort
a.sort()
print(a)#['a', 'b', 'c', 'd', 'w', 'z']
#測試2
a = ['bc','d','cd','a','zr','w','bd']
a.sort()
print(a)#['a', 'bc', 'bd', 'cd', 'd', 'w', 'zr']  #按照字元串首字母排序，首字母相同按第二個字母排序


reverse 
#將列表中的元素反向存放。
a = [2,1,3,4,5]
a.reverse()#沒有返回值，所以只能列印a
print(a)  #[5, 4, 3, 1, 2]


# 列表也可以相加與整數相乘
l1 = [1, 2, 3]
l2 = [4, 5, 6]
print(l1+l2)  # [1, 2, 3, 4, 5, 6]
print(l1*3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]
4.列表的嵌套【必須會，重中之重】
l1 = [1, 2, 'taibai', [1, 'alex', 3,]]
# 1, 將l1中的'taibai'變成大寫並放回原處。
 l1[2] = l1[2].upper()
# 2，給小列表[1,'alex',3,]追加一個元素,'老男孩教育'。
 l1[-1].append('老男孩教育')
# 3，將列表中的'alex'通過字元串拼接的方式在列表中變成'alexsb'
 l1[-1][1] = l1[-1][1] + 'sb'
 l1[-1][1] += 'sb'




lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
# 將列表lis中的"tt"變成大寫（用兩種方式）。
 lis[3][2][1][0] = lis[3][2][1][0].upper()
 lis[3][2][1][0] = 'TT'
# 將列表中的數字3變成字元串"100"（用兩種方式）。
 lis[3][2][1][1] = '100'
 lis[3][2][1][1] = str(lis[3][2][1][1] + 97)
# 將列表中的字元串"1"變成數字101（用兩種方式）。
 lis[3][2][1][2] = 101
 lis[3][2][1][2] = int('10' + lis[3][2][1][2] )
 print(lis)
5.元組(瞭解)

  • Why:對於容器型數據類型list，無論誰都可以對其增刪改查，那麼有一些重要的數據放在list中是不安全的，所以需要一種容器類的數據類型存放重要的數據，創建之初只能查看而不能增刪改，這種數據類型就是元組。

    what:這個容器型數據類型就是元組。

    元組:俗稱不可變的列表,又被成為只讀列表,元組也是python的基本數據類型之一,用小括弧括起來,裡面可以放任何數據類型的數據,查詢可以,迴圈也可以,切片也可以.但就是不能改.

    Where:(用在哪裡)

    ​ 1，就是將一些非常重要的不可讓人改動的數據放在元組中，只供查看。

    ​ 2，常用於元組的拆包

  • 只讀列表。存大量的數據，可以索引，切片（步長）

    #元組的索引切片
tu1 = ('a', 'b', '太白', 3, 666)
print(tu1[0])  # 'a'
print(tu1[-1])  # 666
print(tu1[1:3])  # ('b', '太白')
print(tu1[:-1])  # ('a', 'b', '太白', 3)
print(tu1[::2])  # ('a', '太白', 666)
print(tu1[::-1])  # (666, 3, '太白', 'b', 'a')

tu = (100, '太白', True, [1, 2, 3])
print(tu[0])  #100
print(tu[:3])  #(100, '太白', True)

#元組內嵌套的列表內的元素可更改，但是不能刪除。
tu = (100, '太白', True, [1, 2, 3])
tu[-1].append(597)  #可以更改列表中的數據
print(tu)   #(100, '太白', True, [1, 2, 3, 597])

tu = (100, '太白', True, [1, 2, 3])
del tu[2]  #不能刪除，此時會報錯
print(tu) 

 應用：
# 重要數據，用戶名，密碼，個人信息，不想讓別人改動的一些數據，存在元組中。

 元組的拆包。分別賦值。
 a, b = (1, 2)  # 多一個少一個都不行
 print(a,b)   # 1 2

 c = (1,2)
 a,b = c
 print(a,b)  #1 2

# 可以利用for迴圈查詢，查看
tu1 = ('a', 'b', '太白', 3, 666,True, [1, 2, 3])
for i in tu1:
    print(i)

#index：通過元素找索引（可切片），找到第一個元素就返回，找不到該元素即報錯。
tu = ('太白', [1, 2, 3, ], 'WuSir', '女神')
print(tu.index('太白')) # 0

#count: 獲取某元素在列表中出現的次數
tu = ('太白', '太白', 'WuSir', '吳超')
print(tu.count('太白')) # 2

#len
tu1 = (1,2,3,4,84,5,2,8,2,11,88,2)
print(len(tu1))

結果:
12　


#python中元組有一個特性，元組中如果只含有一個元素且沒有逗號，則該元組不是元組，與該元素數據類型一致，如果有逗號，那麼它是元組。
tu = (1)
print(tu,type(tu))  # 1 <class 'int'>
tu1 = ('alex')
print(tu1,type(tu1))  # 'alex' <class 'str'>
tu2 = ([1, 2, 3])
print(tu2,type(tu2))  # [1, 2, 3] <class 'list'>

tu = (1,)
print(tu,type(tu))  # (1,) <class 'tuple'>
tu1 = ('alex',)
print(tu1,type(tu1))  # ('alex',) <class 'tuple'>
tu2 = ([1, 2, 3],)
print(tu2,type(tu2))  # ([1, 2, 3],) <class 'tuple'>
6.range：

類似於列表，可以自定製數字範圍的數字列表，但是它不是列表。 只能是數字

range與for迴圈結合。

#range：指定範圍，生成指定數字。

# 顧頭不顧腚
r = range(10)  #相當於range(0, 10)   只有一個參數時，預設從0開始，步長為1
print(r)
for i in r:
    print(i)   #列印出0-9
  
#例子    
 for i in range(1,101):
     print(i)   #列印1-100

 for i in range(2,101,2):
     print(i)   #列印100以內所有偶數

 for i in range(1,101,2):  #步長
     print(i)   #列印100以內所有奇數

 for i in range(100,0,-1):   #反向步長
     print(i)   #逆序列印從100到1

#求1-100的和
 sum = 0
 for i in range(1, 101):
     sum += i
 print(sum)

#利用len和range列印列表的索引：利用for迴圈，利用range將l1列表的所有索引依次列印出來
 l1 = [1, 2, 3, 'alex', '太白']
 for i in range(len(l1)):
     print(i)
               
       
# 索引（瞭解）
r = range(10) 
print(r[1])  #1


 for i in range(3):
     pass
 print(i)   #2  迴圈結束後i從0變為2

    
##########面試題##############
##1 ****
l1 = range(5)
print(l1[1:3])  # 正確答案：range(1,3),      錯誤結果： [1,2]  1, 2  

##2
l1 = range(5)
print(l1[-1])   #4   按索引取值

##3
for i in range(1,5,-1):
    print(i)   #什麼都不列印

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • jupyter notebook的插件安裝及文本格式修改
    jupyter notebook的插件安裝及文本格式修改 1.jupyter notebook拓展插件安裝 啟動jupyter notebook : 打開控制台輸入命令 jupyter notebook 安裝Jupyter notebook extensions擴展插件： 1、pip install ...
  • Flask信號
    Flask信號 信號是可以在固定的事件發生時執行某些事情 一個簡單的使用信號的例子： from flask import Flask,signals app = Flask(__name__) def signal_func(*args,**kwargs): print('信號') signals. ...
  • LCA最近公共祖先-- HDU 2586
    題目鏈接 Problem Description There are n houses in the village and some bidirectional roads connecting them. Every day peole always like to ask like this ...
  • C++ Primer 回爐重鑄（一）
    過去學C++語法都是用的這本C++Primer第五版 說實話，這本書應該是業界用的最多的一本類似於C++語法的百科全書了。。 但是感覺自己學了這麼長時間的C++，語法層次還是不夠牢固。 比如template的使用，多個類之間的組合關係.我個人使用的都不是十分熟練。 尤其是在看C++STL源碼刨析的時 ...
  • day21 02 包的進階
    day21 02 包的進階 1._init_.py文件的操作 導入包 根據day21 01 包的初識，建立的glance包，直接import glance後通過“包點包。。點方法”是不能執行所要的方法的，必須通過在一層一層裡面的_init_.py或者其他類似的文件做相對應的導入操作，才可以運行以下代 ...
  • Python爬蟲入門教程： 半次元COS圖爬取
    半次元COS圖爬取-寫在前面 今天在瀏覽網站的時候，忽然一個莫名的鏈接指引著我跳轉到了半次元網站 https://bcy.net/ 打開之後，發現也沒有什麼有意思的內容，職業的敏感讓我瞬間聯想到了 cosplay ，這種網站必然會有這個的存在啊，於是乎，我準備好我的大爬蟲了。 把上面的鏈接打開之後， ...
  • 網路編程-SOCKET開發
    網路編程-SOCKET開發 網路編程架構分類 B/S架構 B指的是web（網頁），S指的是Server（服務端軟體） C/S架構 C指的是Client（客戶端軟體），S指的是Server（服務端軟體） OSI七層模型 OSI七層模型設計的目的 是成為一個所有電腦廠商都能實現的開放網路模型，來剋服使 ...
  • hibernate與struts2整合中出現問題以及一級緩存查詢數據在業務層問題
    直接上問題： 一開始報出 HibernateException，這個問題原因是：struts2和hibernate整合時，有些jar包衝突原因，如Javassist.jar，保留高版本吧。解決jar報衝突問題後又給報錯誤了。 上代碼： 我們知道；對於一些比較複雜的業務，事務都放在業務層開啟和關閉，我 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類