python學習 day05

来源:https://www.cnblogs.com/changwenjun-666/archive/2019/03/22/10580814.html
-Advertisement-
Play Games

一、可變不可變類型 二、數字類型 1.整型 2.浮點型float 總結；數字類型是不可變類型，同時只能存一個值 三、字元串類型 msg='hello' print(msg[0],type(msg[0])) #取其第一個字元，列印其的類型 print(msg[-1]) #從最後第一項索引字元 prin ...


一、可變不可變類型

1. 可變類型：值改變，但是id不變，證明就是在改變原值，是可變類型

L =['a','b','c','d']
print(id(L))
L[0]='A' # 給列表L第一項元素重新賦值
print(L)
print(id(L))
#輸出結果如下：
30237320
['A', 'b', 'c', 'd']
30237320

　

2. 不可變類型：值改變，但是id也跟著變，證明是產生了新的值，是不可變類型

x=11
print(id(x))
x=22
print(id(x))
#輸出結果如下：
8791546520720
8791546521072

　

二、數字類型

1.整型

（1）、用途：記錄年齡、等級、數量
（2）、定義方式
age = 10 # age=int(10)
（3）數據類型轉換：只能將純數字的字元串轉成int
x=int('123123')
print(x,type(x)
#輸出結果如下：
123123 <class 'int'>

x=int('12.3')
#輸出結果如下
ValueError: invalid literal for int() with base 10: '12.3'

2.浮點型float

(1、用途：記錄身高、薪資、體重

(2)、定義方式
 salary = 10.1 # salary=float(10.1)
(3)數據類型轉換: 只能將包含小數的字元串轉成float

x=float('3.1')
print(x,type(x))
#輸出結果如下：
3.1 <class 'float'>

總結；數字類型是不可變類型，同時只能存一個值

 

三、字元串類型

1、用途：記錄描述性質的狀態
2、定義方式：在單引號、雙引號、三引號內包含一串字元串
msg='hello' # msg=str('hello')
小點：
數據類型轉換：所有類型都可以被str轉成字元串類型
res=str([1,2,3])
print(res,type(res))
#輸出結果如下：
[1, 2, 3] <class 'str'>
3、常用操作+內置的方法（掌握程度*****）
3.1、按索引取值(正向取+反向取) ：只能取
msg='hello'
print(msg[0],type(msg[0])) #取其第一個字元，列印其的類型
print(msg[-1])                    #從最後第一項索引字元
print(msg[-2])                    #從最後第二項索引字元
#輸出結果如下：
h <class 'str'>
o
l

msg[0]='H'                        # 只能取，不能用
#輸出結果如下：
'str' object does not support item assignment
View Code 
3.2、切片(顧頭不顧尾，步長）
msg='hello world'
res=msg[0:3:1]  #[0:3:1] 0代表從字元串第一位索引，3代表截止到第三位，1代表步長。
msg='hello world'
res=msg[0:3:1] # 0 1 2
print(res)
print(msg)
#輸出結果如下：
hel
hello world


msg='hello world'              
res=msg[:]                   #不指名兩端位置，預設索引全部
res=msg[::2]               # 0 2 4 6 8 10，此時步長為2
print(res)
#輸出結果如下：
hlowrd

msg='hello world'
res=msg[-1:-12:-1]   # 代表從最後一項開始索引，步長為往左走一步
#res=msg[-1::-1]       同上
#res=msg[::-1]          同上
print(res)
#輸出結構如下：
dlrow olleh
View Code 
3.3、長度len
msg='hello world'
print(len(msg))
#輸出結果如下:
11   #指的是該字元串的長度，包括裡面的空格

3.4、成員運算in和not in:判斷一個子字元串是否存在於大字元串中；not in 代表取反
msg='kevin is dsb'
print('kevin' in msg)
print('b' in msg)
print('aaa' not in msg)
print(not 'aaa' in msg)
#輸出結果如下：                     即只要裡面含有該片段的字元，即為True
True
True
True
True
View Code 
3.5、移除空白strip: 用來去除字元串左右兩邊的字元，不指定預設去除的是空格
msg='      he llo     '
res=msg.strip()        #.strip()預設去除字元串兩邊的空格
print(res,id(res))          
print(msg,id(msg))
#輸出結果如下：
he llo 31293600          #去除兩邊空格後的結果，中間空格沒去除
      he llo      31912776  #原始輸出的結果，發現Id改變了，即字元串是不
                                        可變類型

print('***+-\/***eg*on#@$*****'.strip('*+-\/#@'))
print('***+-\/***eg*on#@$*****'.strip('*+-\/#$@'))
#輸出結果如下：
eg*on#@$    #當.strip()里指定要去除的字元時，看該字元串左右是否存在
eg*on           #要去除的字元，如果存在，即抹去;不存在，保留
View Code 
3.6、切分split：針對有規律的字元串，按照某種分隔符切成列表
info='egon:18:male'
res=info.split(':')    #split(self,sep,maxsplit) 即（分隔符，最大分割數 ）
print(res,type(res))   # 當不知道分割數時，預設走完
print(res[0],res[1])
#輸出結果如下：
['egon', '18', 'male'] <class 'list'>
egon 18

cmd='get|a.txt|33333'
print(cmd.split('|',1)) #此時指定分割數為1，則從左往右分割一個'|'成為                                      #輸出結果如下：         #列表即可      
['get', 'a.txt|33333']
View Code

小點：將其他類型轉變為字元串

用:號作連接符號將純字元串的列表拼接成一個字元串
K=['egon', '18', 'male']  # 想達到 'egon:18:male'
res=K[0]+':'+K[1]+':'+K[2]  #原始方法
res=':'.join(K)             #便捷方法           #'sep'.join.(sep)  'sep'指的是分隔符，可以為空;（sep）指的是要連接的元素序列、字元串、字典、元組、列表        
print(res)                                    #即將字元串、元組、列表中的元素以指定的字元（分隔符）連接生產一個新的字元串
#輸出結果如下：
egon:18:male


3.7、迴圈
for item in 'hello':
    print(item)
#輸出結果如下：
h
e
l
l
o


以下為需要掌握的操作：
1、strip,lstrip,rstrip
print('******egon***********'.strip('*'))   #去除兩邊的‘*’
print('******egon***********'.lstrip('*'))   #去除左邊的'*
print('******egon***********'.rstrip('*'))  #去除右邊的‘*’
#輸出結果如下：        
egon
egon***********
******egon          #用於移除字元串頭尾指定的字元（預設為空格或換行
                             #   符）或字元序列。
View Code 
2、lower,upper，title
print('Abc123 cde'.lower())    #字元串里的字元都小寫
print('Abc123 cde'.upper())   #字元串里的字元都大寫
print('Abc123 cde'.title())      #字元串里的單詞第一個字元大寫
#輸出結果如下：
abc123 cde
ABC123 CDE
Abc123 Cde
View Code 
3、startswith,endswith
msg='alex is dsb'
print(msg.startswith('alex'))
print(msg.endswith('b'))
#輸出結果如下： 
True       
True             #startswith() 方法用於判斷字元串是否以指定首碼開頭，如果
                      是則返回 True，否則返回 False
                   #endswith() 方法用於判斷字元串是否以指定尾碼結尾，如果
                      是則返回True，否則返回False。
View Code 
4、format的三種玩法
res='my name is %s my age is %s' %('egon',18)
print(res)
#輸出結果如下：
my name is egon my age is 18     #此處是占位符的原始使用
                                                 #以下為format的使用
res = 'my name is {name} my age is {age}'.format(age=18, name='egon')
print(res)
#輸出結果如下：                         
my name is egon my age is 18

#瞭解
res='my name is {} my age is {}'.format('egon',18)
print(res)
#輸出結果如下：
my name is egon my age is 18

res='my name is {0}{1} my age is {1}{1}'.format('egon',18)
print(res)
#輸出結果如下：
my name is egon18 my age is 1818
View Code

format使用拓展：

#通過位置
print '{0},{1}'.format('chuhao',20)

print '{},{}'.format('chuhao',20)

print '{1},{0},{1}'.format('chuhao',20)

#通過關鍵字參數
print '{name},{age}'.format(age=18,name='chuhao')

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __str__(self):
        return 'This guy is {self.name},is {self.age} old'.format(self=self)

print str(Person('chuhao',18))

#通過映射 list
a_list = ['chuhao',20,'china']
print 'my name is {0[0]},from {0[2]},age is {0[1]}'.format(a_list)
#my name is chuhao,from china,age is 20

#通過映射 dict
b_dict = {'name':'chuhao','age':20,'province':'shanxi'}
print 'my name is {name}, age is {age},from {province}'.format(**b_dict)
#my name is chuhao, age is 20,from shanxi

#填充與對齊
print '{:>8}'.format('189')
#     189
print '{:0>8}'.format('189')
#00000189
print '{:a>8}'.format('189')
#aaaaa189

#精度與類型f
#保留兩位小數
print '{:.2f}'.format(321.33345)
#321.33

#用來做金額的千位分隔符
print '{:,}'.format(1234567890)
#1,234,567,890

#其他類型 主要就是進位了，b、d、o、x分別是二進位、十進位、八進位、十六進位。

print '{:b}'.format(18) #二進位 10010
print '{:d}'.format(18) #十進位 18
print '{:o}'.format(18) #八進位 22
print '{:x}'.format(18) #十六進位12
View Code 
5、split,rsplit
u="www.doiido.com"
#使用預設空格符來分割
print(u.split())
#輸出結果為：
['www.doiido.com']

#以‘.’為分割符
print(u.split('.'))
#輸出結果：
['www', 'doiido', 'com']

#分割0次
print(u.split('.',0))
#輸出結果為
['www.doiido.com']

#分割一次
print(u.split('.',1))
#輸出結果為：
'www', 'doiido.com']

#分割兩次
print(u.split('.'2))
#輸出結果
['www', 'doiido', 'com']

str：   表示為分隔符，預設為空格，但是不能為空('')。若字元串中沒有分隔符，則把整個字元串作為列表的一個元素
num：表示分割次數。如果存在參數num，則僅分隔成 num+1 個子字元串，並且每一個子字元串可以賦給新的變數
[n]：   表示選取第n個分片


rsplit 待續
View Code 
6、replace
Python replace() 方法把字元串中的 old（舊字元串） 替換成 new(新字元串)，如果指定第三個參數max，則替換不超過 max 次。
msg='apple appld   cppld'
print(msg.replace('p','q'))
#輸出結果
aqqle aqqld   cqqld   #當不指定第三個參數時，會全部替換
 

print(msg.replace('p','q',4))
#當指定第三個參數時，結果如下
aqqle aqqld   cppld      #此時只替換了4次
View Code 
7、isdigit
 isdigit() 方法檢測字元串是否只由數字組成。如果字元串只包含數字則返回 True 否則返回 False
print('123123'.isdigit()) # 如果字元串是由純數字組成的，則返回True
print('123123  '.isdigit())     #此時存在空格，返回False
print('123123asdf'.isdigit())
print('12312.3'.isdigit())
#輸出結果
True
False
False
False
View Code

 

 

瞭解的部分：頭疼，不想看

# 1、find,rfind,index,rindex,count
# print('123 ke123ke'.find('ke'))
# print('123 ke123ke'.rfind('ke'))
# print('123 ke123ke'.index('ke'))
# print('123 ke123ke'.rindex('ke'))

# print('123 ke123ke'.find('xxxx'))
# print('123 ke123ke'.index('xxxx'))
# print('123 ke123ke'.count('ke',0,6))

# 2、center,ljust,rjust,zfill
# print('egon'.center(50,'*'))
# print('egon'.ljust(50,'*'))
# print('egon'.rjust(50,'*'))

# print('egon'.rjust(50,'0'))
# print('egon'.zfill(50))

# 3、captalize,swapcase,title
# print('abcdef dddddd'.capitalize())
# print('abcAef dddddd'.swapcase())
# print('abcAef dddddd'.title())

# 4、is數字系列
num1 = b'4'  # bytes
num2 = '4'  # unicode,python3中無需加u就是unicode
num3 = '四'  # 中文數字
num4 = 'Ⅳ'  # 羅馬數字

# bytes與阿拉伯數字組成的字元串
# print(num1.isdigit())
# print(num2.isdigit())
# print(num3.isdigit())
# print(num4.isdigit())

# 阿拉伯數字組成的字元串
# print(num2.isdecimal())
# print(num3.isdecimal())
# print(num4.isdecimal())

# 阿拉伯數字\中文\羅馬組成的字元串
# print(num2.isnumeric())
# print(num3.isnumeric())
# print(num4.isnumeric())
View Code

 

總結：
存一個值

不可變
例如：通過索引只能取值，不能用該值，strip改變不了原始的狀態。


四、列表類型
1、用途：按照位置記錄多個值，索引對應值
2、定義方式：在[]內用逗號分隔開多個任意類型的值
l=['a',11,11.3,] # l=list(['a',11,11.3,])

數據類型轉換:但凡能夠被for迴圈遍歷的數據類型都可以傳給list，被其轉換成列表
res=list('123')
print(res)
#輸出結果  ['1', '2', '3']

res=list({'a':1,'b':2,'c':3}) # []
print(res)  
#輸出結果   ['a', 'b', 'c']

 3、常用操作+內置的方法
3.1、按索引存取值(正向存取+反向存取)：即可存也可以取
l=['a','b','c','d','e']
print(l[0])    #a
print(l[-1])   #e
print(id(l))   #30171848
l[0]='A'
print(l)       #['A', 'b', 'c', 'd', 'e']
print(id(l))   #30171848                          此時說明列表是可變類型
強調強調強調！！！:對於不存在的索引會報錯
print(l[5])   # list index out of range

dic={"k1":111}      #原始字典
dic['k2']=2222      #加上一個鍵值對
print(dic)          #結果為 {'k1': 111, 'k2': 2222}        證明可存

3.2、切片(顧頭不顧尾，步長)
l=['a','b','c','d','e']
print(l[1:4])         #['b', 'c', 'd']
print(l[::-1])        #['e', 'd', 'c', 'b', 'a']


3.3、長度
l=['a','b','c','d','e']
print(len(l))       #輸出結果為   5

3.4、成員運算in和not in
l=['a','b','c','d','e']   
print('a' in l)                #  True
print('a'not in l)             #False
print(1 not in l)              #True

3.5、追加與insert
l=['a','b','c','d','e']
l.append('xxx')         
l.append('yyy')   #append()將添加的元素加入最後一個位置
print(l)              #'a', 'b', 'c', 'd', 'e', 'xxx', 'yyy']     
l.insert(0,'xxxx')    # 指定位置，添加
print(l)              #['xxxx', 'a', 'b', 'c', 'd', 'e', 'xxx', 'yyy']       
3.6、刪除
del是一種通用的刪除操作，沒有返回值
l=['a','bbb','c','d','e']
del l[0]
print(l)       #['bbb', 'c', 'd', 'e']

dic={'k1':1}
del dic['k1']
print(dic)      #{}     把鍵刪了，對應的值也消失，此時只剩下空的dict


l.remove(指定要刪除的那個元素),沒有返回值
l=['a','bbb','c','d','e']
res=l.remove('bbb')          #刪除‘bbb’,同時給res賦值
print(l)        #['a', 'c', 'd', 'e']            
print(res)      #None           res明顯為空

 2.pop(指定要刪除的那個元素的索引),返回剛剛刪掉的那個元素
l=['a','bbb','c','d','e']
l.pop(-1)         #刪除‘e’
res=l.pop(1)      #給res賦值為l刪除‘bbb’後的列表，同時自身刪除'bbb'
print(l)           #['a', 'c', 'd']
print(res)         #bbb

3.7 迴圈
l=['a','b','c','d','e']
for item in l:
    print(item)  
#輸出結果為：
a
b
c
d
e


隊列與堆棧
# 隊列：先進先出              堆棧:先進後出（後進先出）
# l=[]                      l=[]
# # 入隊                    入隊
# l.append('first')         
# l.append('second')
# l.append('third')
# print(l)
# # 出隊                    出隊
# print(l.pop(0))        print(l(pop(-1）)
# print(l.pop(0))        print（l(pop(-1))
# print(l.pop(0))        print(l(pop(-1))

需要掌握的操作：   append和extend的區別
l=['aaa','bb',345]
l.clear()               #刪除所有
print(l)                #[]
l.append([1,2,3])       #加上集合[1,2,3]
print(l)                #[[1,2,3]] 

l=[1,2,3,4]
l.append([5,6,7])  
print(l)               #[1,2,3,4,[5,6,7]]    

l=[1,2,3,4]
l.extend（[5,6,7]）
print(l)               #[1,2,3,4,5,6,7]

extendextend將它的參數視為 list，extend的行為是把這兩個list接到一起,append是將它的參數視為element，作為一個整體添加上去的。
append是整建制地追加，extend是個體化擴編。
append()方法使用

首先看官方文檔中的描述：

list.extend(L)             Extend the list by appending all the items in the given list; equivalent to a[len(a):] = L.

 翻譯成漢語就是：        通過將所有元素追加到已知list來擴充它，相當於a[len(a):]= L

舉個例子，更能明白這句話

>>> la
[1, 2, 3]
>>> lb
['qiwsir', 'python']
>>> la.extend(lb)
>>> la
[1, 2, 3, 'qiwsir', 'python']
>>> lb
['qiwsir', 'python']

如果有兩個list，一個是la，另外一個lb，將lb追加到la的後面，也就是把lb中的所有元素加入到la中，
即讓la擴容。看代碼
>>> la = [1,2,3]
>>> b = "abc"
>>> la.extend(b)
>>> la
[1, 2, 3, 'a', 'b', 'c']
>>> c = 5
>>> la.extend(c)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  TypeError: 'int' object is not iterable
原來，如果extend(str)的時候，str被以字元為單位拆開，然後追加到la裡面。如果extend的對象是數值型，則報錯。

所以，extend的對象是一個list，如果是str，則python會先把它按照字元為單位轉化為list再追加到已知list。





>>> la
[1, 2, 3, 'a', 'b', 'c']
>>> lb
['qiwsir', 'python']
>>> la[len(la):]=lb
>>> la
[1, 2, 3, 'a', 'b', 'c', 'qiwsir', 'python']

為什會出現輸入la，運行後 [1, 2, 3, 'a', 'b', 'c', 'qiwsir', 'python']   因為  list.extend(L) 等效於 list[len(list):] = L，  L是待併入的list。




extend（）方法使用
>>> new = [1,2,3]
>>> lst = ['python','qiwsir']
>>> lst.extend(new)
>>> lst
['python', 'qiwsir', 1, 2, 3]
>>> new
[1, 2, 3]
通過extend函數，將[1,2,3]中的每個元素都拿出來，然後塞到lst裡面，從而得到了一個跟原來的對象元素不一樣的列表，後面的比原來的多了三個元素。

還要關註一下，從上面的演示中可以看出，lst經過extend函數操作之後，變成了一個貌似“新”的列表。這句話好像有點彆扭，“貌似新”的，之所以這麼說，是因為對“新的”可能有不同的理解。不妨深挖一下。

>>> new = [1,2,3]
>>> id(new)
3072383244L

>>> lst = ['python', 'qiwsir']
>>> id(lst)
3069501420L
用id()能夠看到兩個列表分別在記憶體中的“窩”的編號。

>>> lst.extend(new)
>>> lst
['python', 'qiwsir', 1, 2, 3]
>>> id(lst)
3069501420L
註意到沒有？雖然lst經過extend()方法之後，比原來擴容了，但是，並沒有離開原來的“窩”，也就是在記憶體中，還是“舊”的，只不過裡面的內容增多了。相當於兩口之家，經過一番雲雨之後，又增加了一個小寶寶，那麼這個家是“新”的還是“舊”的呢？角度不同或許說法不一了。

這就是列表的一個重要特征：列表是可以修改的。這種修改，不是複製一個新的，而是在原地進行修改。

其實，append()對列表的操作也是如此，不妨用同樣的方式看看。

說明：雖然這裡的lst內容和上面的一樣，但是，我從新在shell中輸入，所以id會變化。也就是記憶體分配的“窩”的編號變了。

>>> lst = ['python','qiwsir']
>>> id(lst)     
3069501388L
>>> lst.append(new)
>>> lst
['python', 'qiwsir', [1, 2, 3]]
>>> id(lst)
3069501388L
顯然，append()也是原地修改列表。

如果，對於extend()，提供的不是iterable類型對象，會如何呢？

>>> lst.extend("itdiffer")
>>>
您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • IO流基礎
    1.位元組流 1.1 位元組輸入流【inputStream】 java.io.InputStream 抽象類是表示位元組輸入流的所有類的超類，可以讀取位元組信息到記憶體中。 它定義了位元組輸入流的基本共性功能方法。 public void close() ：關閉此輸入流並釋放與此流相關聯的任何系統資源。 pub ...
  • 初識Python
    Python誕生至今 python的創始人為吉多·範羅蘇姆（Guido van Rossum）荷蘭人，1989年的聖誕節期間，吉多·範羅蘇姆為了在阿姆斯特丹打發時間，決心開發一個新的腳本解釋程式，作為ABC語言的一種繼承。Python是一種面向對象的解釋型電腦程式設計語言，第一個公開發行版發行於1 ...
  • python學習之數組二
    作用於數組的函數： 通用函數：函數基於元素的，以單元方式作用於數組的，返回的是與原數組具有相同形狀的數組。 不通用函數（數組函數）：函數能以行或者列的方式作用於整個矩陣；如果沒有提供任何參數時，它們將作用於整個矩陣。例如：max、sum和min等函數 例如：A=array([[1,2,3,4],[5 ...
  • C++學習第一天(helloword)
    C++編譯過程 1 #include <iostream> 2 //iostream 提供了一個叫命名空間的東西，標準的命名空間是std 包含了有關輸入輸出語句的函數 3 // input&^output 4 //stream 流 5 //命名空間 6 using namespace std; 7 ...
  • python函數
    一、函數引入 與數學中的函數不同，在Python中，函數不是看上去冰冷無聊的規則和公式，而是有實打實的、有自己作用的代碼。比如說當我們需要實現“列印”這個功能，我們會用到print()；當我們需要實現“獲取數據長度”這個功能，我們會要到len()。這些都是設定好了，可以直接拿過來就用的功能，這就叫做 ...
  • python運算符優先順序表
    自上向下，優先順序越來越高 ...
  • python+redis簡單實現發紅包程式
    redis是什麼？ Redis 是一個高性能的key-value資料庫！ 想進一步瞭解請移步搜索引擎自行查找。 編寫這個小程式的目的就是對redis進行一個簡單的小操作，對redis有一個初步的瞭解，並未有什麼高大尚的騷操作，適合小白閱讀。 程式共分為三個部分。 1.創建紅包 2.將紅包存儲到資料庫 ...
  • Python入門必學，用Python練習畫個美隊盾牌
    這是一篇用Python畫畫的文章，更多有趣、好玩的Python應用、實戰盡在知識星球「人人都是Pythonista」。 關註公眾號「**Python專欄**」，回覆：**美隊盾牌**，獲取全套代碼！ ...
一周排行
    -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.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類