一、整型(int)

　在32位機器上，整數的位數爲32位，取值範圍爲-2**31～2**31-1，即-2147483648～2147483647

　在64位系統上，整數的位數爲64位，取值範圍爲-2**63～2**63-1，即-9223372036854775808～922337203685477580

1.數字類型的創建

a=10
b=a
b=666
  
print(a)#10
print(b)#666

2.int類型轉換

var1=3.14
var2=5
var3=int(var1)
var4=float(var2)
  
print(var3,var4)

3.內置的數學函數

# abs(x) 返回數字的絕對值，如abs(-10) 返回 10

# ceil(x) 返回數字的上入整數，如math.ceil(4.1) 返回 5

# cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1

# exp(x) 返回e的x次冪(ex),如math.exp(1) 返回2.718281828459045

# fabs(x) 返回數字的絕對值，如math.fabs(-10) 返回10.0

# floor(x) 返回數字的下舍整數，如math.floor(4.9)返回 4

# log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0

# log10(x) 返回以10爲基數的x的對數，如math.log10(100)返回 2.0

# max(x1, x2,...) 返回給定參數的最大值，參數可以爲序列。

# min(x1, x2,...) 返回給定參數的最小值，參數可以爲序列。

# modf(x) 返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示。

# pow(x, y) x**y 運算後的值。

# round(x [,n]) 返回浮點數x的四捨五入值，如給出n值，則代表舍入到小數點後的位數。

# sqrt(x) 返回數字x的平方根，數字可以爲負數，返回類型爲實數，如math.sqrt(4)返回 2+0j

二、字符串(str)

字符串是以單引號'或雙引號"括起來的任意文本，比如'abc'，"123"等等。

請注意，''或""本身只是一種表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c這3個字符。如果'本身也是一個字符，那就可以用""括起來，比如"I'm OK"包含的字符是I，'，m，空格，O，K這6個字符。

1.創建字符串

var1 = 'Hello World!'
var2 = "Python RAlvin"

2.內置的字符串函數

# string.capitalize() 把字符串的第一個字符大寫

# string.center(width) 返回一個原字符串居中,並使用空格填充至長度 width 的新字符串

# string.count(str, beg=0, end=len(string)) 返回 str 在 string 裏面出現的次數，如果 beg 或者 end 指定則返回指定範圍內 str 出現的次數

# string.decode(encoding='UTF-8', errors='strict') 以 encoding 指定的編碼格式解碼 string，如果出錯默認報一個 ValueError 的異常，除非 errors 指定的是 'ignore' 或者'replace'

# string.encode(encoding='UTF-8', errors='strict') 以 encoding 指定的編碼格式編碼 string，如果出錯默認報一個ValueError 的異常，除非 errors 指定的是'ignore'或者'replace'

# string.endswith(obj, beg=0, end=len(string)) 檢查字符串是否以 obj 結束，如果beg 或者 end 指定則檢查指定的範圍內是否以 obj 結束，如果是，返回 True,否則返回 False.

# string.expandtabs(tabsize=8) 把字符串 string 中的 tab 符號轉爲空格，tab 符號默認的空格數是 8。

# string.find(str, beg=0, end=len(string)) 檢測 str 是否包含在 string 中，如果 beg 和 end 指定範圍，則檢查是否包含在指定範圍內，如果是返回開始的索引值，否則返回-1

# string.index(str, beg=0, end=len(string)) 跟find()方法一樣，只不過如果str不在 string中會報一個異常.

# string.isalnum() 如果 string 至少有一個字符並且所有字符都是字母或數字則返回 True,否則返回 False

# string.isalpha() 如果 string 至少有一個字符並且所有字符都是字母則返回 True,否則返回 False

# string.isdecimal() 如果 string 只包含十進制數字則返回 True 否則返回 False.

# string.isdigit() 如果 string 只包含數字則返回 True 否則返回 False.

# string.islower() 如果 string 中包含至少一個區分大小寫的字符，並且所有這些(區分大小寫的)字符都是小寫，則返回 True，否則返回 False

# string.isnumeric() 如果 string 中只包含數字字符，則返回 True，否則返回 False

# string.isspace() 如果 string 中只包含空格，則返回 True，否則返回 False.

# string.istitle() 如果 string 是標題化的(見 title())則返回 True，否則返回 False

# string.isupper() 如果 string 中包含至少一個區分大小寫的字符，並且所有這些(區分大小寫的)字符都是大寫，則返回 True，否則返回 False

# string.join(seq) 以 string 作爲分隔符，將 seq 中所有的元素(的字符串表示)合併爲一個新的字符串

# string.ljust(width) 返回一個原字符串左對齊,並使用空格填充至長度 width 的新字符串

# string.lower() 轉換 string 中所有大寫字符爲小寫.

# string.lstrip() 截掉 string 左邊的空格

# string.maketrans(intab, outtab]) maketrans() 方法用於創建字符映射的轉換表，對於接受兩個參數的最簡單的調用方式，第一個參數是字符串，表示需要轉換的字符，第二個參數也是字符串表示轉換的目標。

# max(str) 返回字符串 str 中最大的字母。

# min(str) 返回字符串 str 中最小的字母。

# string.partition(str) 有點像 find()和 split()的結合體,從 str 出現的第一個位置起,把字符串 string 分成一個 3 元素的元組 (string_pre_str,str,string_post_str),如果 string 中不包含str 則 string_pre_str == string.

# string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替換成 str2,如果 num 指定，則替換不超過 num 次.

# string.rfind(str, beg=0,end=len(string) ) 類似於 find()函數，不過是從右邊開始查找.

# string.rindex( str, beg=0,end=len(string)) 類似於 index()，不過是從右邊開始.

# string.rjust(width) 返回一個原字符串右對齊,並使用空格填充至長度 width 的新字符串

# string.rpartition(str) 類似於 partition()函數,不過是從右邊開始查找.

# string.rstrip() 刪除 string 字符串末尾的空格.

# string.split(str="", num=string.count(str)) 以 str 爲分隔符切片 string，如果 num有指定值，則僅分隔 num 個子字符串

# string.splitlines(num=string.count('\n')) 按照行分隔，返回一個包含各行作爲元素的列表，如果 num 指定則僅切片 num 個行.

# string.startswith(obj, beg=0,end=len(string)) 檢查字符串是否是以 obj 開頭，是則返回 True，否則返回 False。如果beg 和 end 指定值，則在指定範圍內檢查.

# string.strip([obj]) 在 string 上執行 lstrip()和 rstrip()

# string.swapcase() 翻轉 string 中的大小寫

# string.title() 返回"標題化"的 string,就是說所有單詞都是以大寫開始，其餘字母均爲小寫(見 istitle())

# string.translate(str, del="") 根據 str 給出的表(包含 256 個字符)轉換 string 的字符,要過濾掉的字符放到 del 參數中

# string.upper() 轉換 string 中的小寫字母爲大寫

name = "alex li"
name.capitalize() 首字母大寫
name.casefold() 大寫全部變小寫
name.center(50,"-") 輸出 '---------------------Alex Li----------------------'
name.count('lex') 統計 lex出現次數
name.encode() 將字符串編碼成bytes格式
name.endswith("Li") 判斷字符串是否以 Li結尾
"Alex\tLi".expandtabs(10) 輸出'Alex Li'， 將\t轉換成多長的空格
name.find('A') 查找A,找到返回其索引， 找不到返回-1

format :
>>> msg = "my name is {}, and age is {}"
>>> msg.format("alex",22)
'my name is alex, and age is 22'
>>> msg = "my name is {1}, and age is {0}"
>>> msg.format("alex",22)
'my name is 22, and age is alex'
>>> msg = "my name is {name}, and age is {age}"
>>> msg.format(age=22,name="ale")
'my name is ale, and age is 22'
format_map
>>> msg.format_map({'name':'alex','age':22})
'my name is alex, and age is 22'


msg.index('a') 返回a所在字符串的索引
'9aA'.isalnum() True

'9'.isdigit() 是否整數
name.isnumeric
name.isprintable
name.isspace
name.istitle
name.isupper
"|".join(['alex','jack','rain'])
'alex|jack|rain'


maketrans
>>> intab = "aeiou" #This is the string having actual characters.
>>> outtab = "12345" #This is the string having corresponding mapping character
>>> trantab = str.maketrans(intab, outtab)
>>>
>>> str = "this is string example....wow!!!"
>>> str.translate(trantab)
'th3s 3s str3ng 2x1mpl2....w4w!!!'

msg.partition('is') 輸出 ('my name ', 'is', ' {name}, and age is {age}')

>>> "alex li, chinese name is lijie".replace("li","LI",1)
'alex LI, chinese name is lijie'

msg.swapcase 大小寫互換


>>> msg.zfill(40)
'00000my name is {name}, and age is {age}'



>>> n4.ljust(40,"-")
'Hello 2orld-----------------------------'
>>> n4.rjust(40,"-")
'-----------------------------Hello 2orld'


>>> b="ddefdsdff_哈哈"
>>> b.isidentifier() #檢測一段字符串可否被當作標誌符，即是否符合變量命名規則
True

3.字符串的切片

切片的語法表達式爲：[start_index : end_index : step]，其中：

start_index：起始索引
end_index：結束索引
step：步長

切片操作是指按照步長，截取從起始索引到結束索引，但不包含結束索引（也就是結束索引減1）的所有元素。

切片不會改變原對象，而是重新生成了一個新的對象

str1 = "hello world"

print(str1[1:6])    # 結果是ello

print(str1[1:6:2])    # 結果是el

print(str1[2:])    # 結果是llo world
# 保留start_index，但省略end_index，這樣會從起始索引開始，切到最後一個元素爲止


print(str1[:5])    # 結果是hello
# 省略start_index，保留end_index，這樣會從第一個元素開始，切到end_index - 1的元素爲止

print(str1[-1:-6:-1])    # 結果是dlrow

print(str1[1:6:-1])    # 結果爲空
# 切片時,一定要保證start_index到end_index的方向與步長step的方向同向，否則會切出空的序列

4.字符串的拼接

Python的字符串格式化有兩種方式: 百分號方式、format方式

百分號方式

格式：%[(name)][flags][width].[precision]typecode

(name) 可選，用於選擇指定的key
flags 可選，可供選擇的值有:
- + 右對齊；正數前加正好，負數前加負號；
- - 左對齊；正數前無符號，負數前加負號；
- 空格右對齊；正數前加空格，負數前加負號；
- 0 右對齊；正數前無符號，負數前加負號；用0填充空白處
width 可選，佔有寬度
precision 可選，小數點後保留的位數
typecode 必選
- s，獲取傳入對象的__str__方法的返回值，並將其格式化到指定位置
- r，獲取傳入對象的__repr__方法的返回值，並將其格式化到指定位置
- c，整數：將數字轉換成其unicode對應的值，10進制範圍爲 0 <= i <= 1114111（py27則只支持0-255）；字符：將字符添加到指定位置
- o，將整數轉換成八進製表示，並將其格式化到指定位置
- x，將整數轉換成十六進制表示，並將其格式化到指定位置
- d，將整數、浮點數轉換成十進製表示，並將其格式化到指定位置
- e，將整數、浮點數轉換成科學計數法，並將其格式化到指定位置（小寫e）
- E，將整數、浮點數轉換成科學計數法，並將其格式化到指定位置（大寫E）
- f，將整數、浮點數轉換成浮點數表示，並將其格式化到指定位置（默認保留小數點後6位）
- F，同上
- g，自動調整將整數、浮點數轉換成浮點型或科學計數法表示（超過6位數用科學計數法），並將其格式化到指定位置（如果是科學計數則是e；）
- G，自動調整將整數、浮點數轉換成浮點型或科學計數法表示（超過6位數用科學計數法），並將其格式化到指定位置（如果是科學計數則是E；）
- %，當字符串中存在格式化標誌時，需要用 %%表示一個百分號

注：Python中百分號格式化是不存在自動將整數轉換成二進制表示的方式

常用格式化：

tpl = "i am %s" % "alex"
  
tpl = "i am %s age %d" % ("alex", 18)
  
tpl = "i am %(name)s age %(age)d" % {"name": "alex", "age": 18}
  
tpl = "percent %.2f" % 99.97623
  
tpl = "i am %(pp).2f" % {"pp": 123.425556, }
  
tpl = "i am %.2f %%" % 123.425556

format方式

格式：[[fill]align][sign][#][0][width][,][.precision][type]

fill 【可選】空白處填充的字符
align 【可選】對齊方式（需配合width使用）
- <，內容左對齊
- >，內容右對齊(默認)
- ＝，內容右對齊，將符號放置在填充字符的左側，且只對數字類型有效。即使：符號+填充物+數字
- ^，內容居中
sign 【可選】有無符號數字
- +，正號加正，負號加負；
- -，正號不變，負號加負；
- 空格，正號空格，負號加負；
# 【可選】對於二進制、八進制、十六進制，如果加上#，會顯示 0b/0o/0x，否則不顯示
，【可選】爲數字添加分隔符，如：1,000,000
width 【可選】格式化位所佔寬度
.precision 【可選】小數位保留精度
type 【可選】格式化類型

傳入“ 浮點型或小數類型 ”的參數
- 傳入” 字符串類型 “的參數
  - s，格式化字符串類型數據
  - 空白，未指定類型，則默認是None，同s
- 傳入“ 整數類型 ”的參數
  - b，將10進制整數自動轉換成2進製表示然後格式化
  - c，將10進制整數自動轉換爲其對應的unicode字符
  - d，十進制整數
  - o，將10進制整數自動轉換成8進製表示然後格式化；
  - x，將10進制整數自動轉換成16進製表示然後格式化（小寫x）
  - X，將10進制整數自動轉換成16進製表示然後格式化（大寫X）
  - e，轉換爲科學計數法（小寫e）表示，然後格式化；
  - E，轉換爲科學計數法（大寫E）表示，然後格式化;
  - f ，轉換爲浮點型（默認小數點後保留6位）表示，然後格式化；
  - F，轉換爲浮點型（默認小數點後保留6位）表示，然後格式化；
  - g，自動在e和f中切換
  - G，自動在E和F中切換
  - %，顯示百分比（默認顯示小數點後6位）

　　常用格式化：

tpl = "i am {}, age {}, {}".format("seven", 18, 'alex')
   
tpl = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])
   
tpl = "i am {0}, age {1}, really {0}".format("seven", 18)
   
tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])
   
tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
   
tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})
   
tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
   
tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
   
tpl = "i am {:s}, age {:d}".format(*["seven", 18])
   
tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)
   
tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})
  
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
  
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
  
tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
  
tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)

三、字節類型(bytes)

# a=bytes('hello','utf8')
# a=bytes('中國','utf8')
  
a=bytes('中國','utf8')
b=bytes('hello','gbk')

print(a)        #b'\xe4\xb8\xad\xe5\x9b\xbd'
print(ord('h')) #其十進制 unicode 值爲: 104
print(ord('中'))#其十進制 unicode 值爲:20013
  
#  h   e  l   l   o
# 104 101 108 108 111   編碼後結果:與ASCII表對應
  
  
#     中                國
#   \xd6\xd0         \xb9\xfa       gbk編碼後的字節結果
#\xe4 \xb8 \xad   \xe5 \x9b \xbd    utf8編碼後的字節結果
# 228 184 173      229 155  189        a[:]切片取
  
  
c=a.decode('utf8')
d=b.decode('gbk')
#b=a.decode('gbk') :很明顯報錯
  
print(c) #中國
print(d) #hello

注意：對於 ASCII 字符串，因爲無論哪種編碼對應的結果都是一樣的，所以可以直接使用 b'xxxx' 賦值創建 bytes 實例，但對於非 ASCII 編碼的字符則不能通過這種方式創建 bytes 實例，需要指明編碼方式。

四、布爾類型(bool)

個布爾值只有True、False兩種值，要麼是True，要麼是False，在Python中，可以直接用True、False表示布爾值（請注意大小寫）

print(True)
print(4>2)
print(bool([3,4]))
print(True+1)

# 是與非的操作：
bool(1 and 0)
bool(1 and 1)
bool(1 or 0)
bool(not 0)

# 布爾值 經常用在條件判斷中：
age=18
if age>18:#bool(age>18)
    print('old')
else:
    print('young')

五、列表、元組的操作

列表（list）是Python以及其他語言中最常用到的數據結構之一。Python使用使用中括號 [ ] 來解析列表。列表是可變的（mutable）——可以改變列表的內容。

1.查

names_class2=['張三','李四','王五','趙六']
  
# print(names_class2[2])
# print(names_class2[0:3])
# print(names_class2[0:7])
# print(names_class2[-1])
# print(names_class2[2:3])
# print(names_class2[0:3:1])
# print(names_class2[3:0:-1])
# print(names_class2[:])

2.增(append,insert)

insert 方法用於將對象插入到列表中，而append方法則用於在列表末尾追加新的對象

names_class2.append('alex')
names_class2.insert(2,'alvin')
print(names_class2)

3.改(重新賦值)

names_class2=['張三','李四','王五','趙六']
  
names_class2[3]='趙七'
names_class2[0:2]=['wusir','alvin']
print(names_class2)

4.刪除(remove,pop,del)

names_class2.remove('alex')
del names_class2[0]
del names_class2
names_class2.pop()#注意,pop是有一個返回值的

5.其它的一些操作

# count 方法統計某個元素在列表中出現的次數：
>>> ['to', 'be', 'or', 'not', 'to', 'be'].count('to')
2
>>> x = [[1,2], 1, 1, [2, 1, [1, 2]]]
>>> x.count(1)
2
>>> x.count([1,2])
1



# extend 方法可以在列表的末尾一次性追加另一個序列中的多個值。
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]

# extend 方法修改了被擴展的列表，而原始的連接操作（+）則不然，它會返回一個全新的列表。
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]
>>>
>>> a + b
[1, 2, 3, 4, 5, 6, 4, 5, 6]
>>> a
[1, 2, 3, 4, 5, 6]



# index 方法用於從列表中找出某個值第一個匹配項的索引位置
names_class2.index('李四')

# reverse 方法將列表中的元素反向存放。
names_class2.reverse()
print(names_class2)


# sort 方法用於在原位置對列表進行排序。
x = [4, 6, 2, 1, 7, 9]
x.sort() # 正序 
#x.sort(reverse=True)    # 倒序

注：

元組被稱爲只讀列表，即數據可以被查詢，但不能被修改，所以，列表的切片操作同樣適用於元組。

元組寫在小括號()裏，元素之間用逗號隔開。

1 對於一些數據我們不想被修改，可以使用元組；

2 另外，元組的意義還在於，元組可以在映射（和集合的成員）中當作鍵使用——而列表則不行；元組作爲很多內建函數和方法的返回值存在。

六、字典

字典是python中唯一的映射類型，採用鍵值對（key-value）的形式存儲數據。python對key進行哈希函數運算，根據計算的結果決定value的存儲地址，所以字典是無序存儲的，且key必須是可哈希的。可哈希表示key必須是不可變類型，如：數字、字符串、元組。

字典(dictionary)是除列表之外python之中最靈活的內置數據結構類型。列表是有序的對象結合，字典是無序的對象集合。兩者之間的區別在於：字典當中的元素是通過鍵來存取的，而不是通過偏移存取

1.創建字典

dic1={'name':'alex','age':36,'sex':'male'}
dic2=dict((('name','alex'),))
print(dic1)
print(dic2)

2.字典的操作：增

dic3={}
  
dic3['name']='alex'
dic3['age']=18
print(dic3)#{'name': 'alex', 'age': 18}
# key如果字典中已經存在就不做任何操作，如果key沒有就增加

3.字典的操作：查

dic3={'name': 'alex', 'age': 18}
  
# print(dic3['name'])
# print(dic3['names'])
#
# print(dic3.get('age',False))
# print(dic3.get('ages',False))
  
print(dic3.items())
print(dic3.keys())
print(dic3.values())
  
print('name' in dic3)# py2:  dic3.has_key('name')
print(list(dic3.values()))

4.字典的操作：修改

dic3={'name': 'alex', 'age': 18}
  
dic3['name']='alvin'
dic4={'sex':'male','hobby':'girl','age':36}
dic3.update(dic4)
print(dic3)

5.字典的操作：刪除

dic4={'name': 'alex', 'age': 18,'class':1}
  
  
# dic4.clear()
# print(dic4)
del dic4['name']
print(dic4)
  
a=dic4.popitem()
print(a,dic4)
  
# print(dic4.pop('age'))
# print(dic4)
  
# del dic4
# print(dic4)

6.字典的遍歷

dic5={'name': 'alex', 'age': 18}
  
for i in dic5:
    print(i,dic5[i])
  
for items in dic5.items():
    print(items)
for keys,values in dic5.items():
    print(keys,values)

Python 常用的數據類型

一、整型(int)

1.數字類型的創建

2.int類型轉換

3.內置的數學函數

二、字符串(str)

1.創建字符串

2.內置的字符串函數

3.字符串的切片

4.字符串的拼接

三、字節類型(bytes)

四、布爾類型(bool)

五、列表、元組的操作

1.查

2.增(append,insert)

3.改(重新賦值)

4.刪除(remove,pop,del)

5.其它的一些操作

六、字典

1.創建字典

2.字典的操作：增

3.字典的操作：查

4.字典的操作：修改

5.字典的操作：刪除

6.字典的遍歷

PDManer [元數建模]-v4.9.0 發佈：一款簡單好用的數據庫建模平臺

使用neovim打造go ide(支持代碼跳轉, 代碼補全, 實時語法檢查)

sql求連續值問題

cs01 CSS Syntax

挑戰程序設計競賽 2.3章習題 poj 3046 Ant Counting

[MASM拾遺]Offset僞指令

h30 HTML Layout Elements

瞭解顯卡

一款基於C#開發的通訊調試工具（支持Modbus RTU、MQTT調試）

Linux/Golang/glibC系統調用

Python 常用的數據類型

windows下兼容Python2和Python3的解決方法

SSL證書的生成

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結