Python基礎學習篇

簡介：

　　Python由荷蘭數學和計算機科學研究學會的吉多·范羅蘇姆（Guido van Rossum）于1990 年代初設計，Python語法和動態型別，以及解釋型語言的本質，使它成為多數平臺上快速開發應用的編程語言，

　　Python可以應用于眾多領域，如：資料分析、網路服務、影像處理、數值計算和科學計算等眾多領域，互聯網公司廣泛使用Python來做的事一般有：自動化運維、自動化測驗、大資料分析、爬蟲、Web開發等，

　　2021年，Tiobe將Python加冕為最受歡迎的編程語言，20年來首次將其置于Java、C之上，

資料型別：

　　　　　　　　　　　　　　　　　　Python3 的八個標準資料型別:

Python3 的八個標準資料型別中：

• 不可變資料（3 個）：Number（數字）、String（字串）、Tuple（元組）；
• 可變資料（3 個）：List（串列）、Dictionary（字典）、Set（集合），

NUMBER

　　數字資料型別用于存盤數值，資料型別是不允許改變的,這就意味著如果改變數字資料型別的值，將重新分配記憶體空間，

數學函式

 1 # 回傳數字的絕對值
 2 abs(-5)
 3 # 回傳數字的上入整數
 4 import math
 5 print(math.ceil(3.2))
 6 # 回傳e的冪次方
 7 math.exp(3)
 8 # 回傳數字flot型別的絕對值
 9 math.fabs(-3)
10 # 回傳數字的下舍整數
11 math.floor(3.7)
12 # 回傳數字的自然對數
13 math.log(7.31)
14 # 回傳以10為基數的自然對數
15 math.log10(7)
16 # 回傳給定引數的最大值
17 max(5,7,9,14)
18 # 回傳給定引數的最小值
19 min(5,7,9,14)
20 # 回傳數值的整數部分和小數部分，以浮點型表示
21 math.modf(37.5)
22 # 回傳2的3次方
23 pow(2,3)
24 # 四舍五入，給出n則保留小數位數
25 round(3.141592,3)
26 round(3.741592)
27 # 開平方
28 math.sqrt(4)

亂數函式

　　亂數可以用于數學，安全等領域中，經常被嵌入到演算法中，提高演算法效率，以及提高程式的安全性，

 1 # 從序列中隨機挑選一個元素
 2 import random
 3 random.choice(range(20))
 4 # 遞增基數集合中的一個亂數，基數默認值為1
 5 random.randrange(5,30,2)
 6 # 生成0到1之間的一個亂數
 7 random.random()
 8 # 隨機排序
 9 wu = [3,5,1,7]
10 random.shuffle(wu)
11 print(wu)
12 # 生成指定范圍內的一個數
13 random.uniform(2,10)

三角函式

 1 import math
 2 
 3 # 反余弦弧度值
 4 math.acos(8)
 5 # 反正弦弧度值
 6 math.asin(8)
 7 # 反正切弧度值
 8 math.atan(8)
 9 # x和y坐標的反正切值
10 math.atan2(6,7)
11 # 弧度的余弦值
12 math.cos(7)
13 # 歐幾里得范數
14 math.hypot(2,3)
15 # 弧度的正弦值
16 math.sin(9)
17 # 弧度的正切值
18 math.tan(6)
19 # 將弧度轉為角度
20 math.degrees(5)
21 # 將角度轉為弧度
22 math.radians(5)

STR

　　字串是 Python 中最常用的資料型別，我們可以使用單引號或雙引號來創建字串，

創建

1 wu = 'cloud'
2 zhang = "Fang"

查詢

1 # 查詢第一個元素
2 wu[0]
3 # 查詢第二個到第四個元素，不包含第四個
4 wu[1:3]

修改

1 # 修改第五個元素之后的值
2 wu[:4]+'s'

內置方法

  1 # 第一個字符轉為大寫
  2 wu.capitalize()
  3 # 將字串居中，兩邊按指定字符填充
  4 wu.center(31,'*')
  5 # 統計字符在字串中出現的次數，可以指定匹配范圍
  6 fe = 'haffsfjajldjafjkaklfjkajfka'
  7 fe.count('j',2,17)
  8 # 編碼,將字串轉為bytes型別
  9 he = wu.encode(encoding='utf-8')
 10 print(he)
 11 # 解碼,將bytes型別轉為字串
 12 wu = he.decode(encoding='utf8')
 13 print(wu)
 14 # 檢查字串是否以某個字符開頭，可以指定范圍
 15 fe1 = 'ha'
 16 fe.startswith(fe1)
 17 fe.atartswith(fe1,0,18)
 18 # 檢查字串是否以某個字符結束，可以指定范圍
 19 fe1 = 'aj'
 20 fe.endswith(fe1)
 21 fe.endswith(fe1,2,18)
 22 # 將字串中tab符號轉化為空格,默認是8個空格，可以指定數量
 23 fe2 = 'jdalkjsfkl\tsadlkjal'
 24 fe3 = fe2.expandtabs()
 25 print(fe3)
 26 fe3 = fe2.expandtabs(3)
 27 print(fe3)
 28 # 從左邊開始檢查字串中是否包含該字符，可指定范圍，包含回傳索引，不包含回傳-1
 29 fe2.find('sfk',2,15)
 30 # 從右邊開始檢查字串中是否包含該字符，可指定范圍，包含回傳索引，不包含回傳-1
 31 fe2.rfind('sfk',2,15)
 32 # 從左邊開始檢查字串中是否包含該字符,可指定范圍，包含返回索引，不存在發生例外
 33 fe2.index('sfk',3,13)
 34 # 從右邊開始檢查字串中是否包含該字符,可指定范圍，包含回傳索引，不存在發生例外
 35 fe2.rindex('sfk',3,13)
 36 # 判斷所有字符是否都是字母或數字
 37 fe2.isalnum()
 38 # 判斷所有字符是否都是字母或中文
 39 fe2.isalpha()
 40 # 1、判斷所有字符是否都是數字
 41 s4 = '123546'
 42 s4.isdigit()
 43 # 2、判斷所有字符是否都是數字
 44 s4.isnumeric()
 45 # 判斷所有字母是否都是大寫
 46 s5 = 'DFHFSJKFH'
 47 s5.islower()
 48 # 判斷所有字母是否都是小寫
 49 s6 = 'dhfshsf'
 50 s6.isupper()
 51 # 判斷是否是空字串
 52 s7 = "   "
 53 s7.isspace()
 54 # 檢查首字母是否是大寫
 55 s8 = 'Hello!'
 56 s8.istitle()
 57 # 以指定字符為分隔符，拼接序列內的所有元素，回傳一個新字串
 58 s9 = '-'
 59 li = ['c','l','o','u','d']
 60 s9.join(li)
 61 # 回傳字串長度
 62 len(s8)
 63 # 將原字串左對齊，并*填充至長度30,默認使用空格填充
 64 s8.ljust(30,'*')
 65 # 將原字串右對齊，并*填充至長度30,默認使用空格填充
 66 s8.rjust(30,'*')
 67 # 將原字串右對齊，并0填充至長度30
 68 s8.zfill(30)
 69 # 截取字串頭尾的字符或空格
 70 s9 = '   sjdkaj  '
 71 s9.strip()
 72 s10 = 'dkshdk'
 73 s10.lstrip('dk')
 74 # 截取字串左邊的字符或空格
 75 s9 = '   sjdkaj  '
 76 s9.lstrip()
 77 s10 = 'dkshdk'
 78 s10.lstrip('dk')
 79 # 截取字串右邊的字符或空格
 80 s9 = '   sjdkaj  '
 81 s9.rstrip()
 82 s10 = 'dkshdk'
 83 s10.rstrip('dk')
 84 # 回傳字串中最大字母
 85 max(s10)
 86 # 回傳字串中最小字母
 87 min(s10)
 88 # 字符h替換成s12的字符1次
 89 s11 = 'hfjhfhSDfhksfh'
 90 s12 = 'zz'
 91 s11.replace('h',s12,1)
 92 # 按指定字符截取字串，可指定截取次數
 93 s11.split('f',2)
 94 # 將所有大寫字符轉化為小寫
 95 s11.lower()
 96 # 字串反轉，大寫轉小寫，小寫轉大寫
 97 s11.swapcase()
 98 # 將字串首字母大寫
 99 s11.title()
100 # 小寫轉大寫
101 s11.upper()
102 # 檢查是否包含十進制字符
103 s11.isdecimal()

LIST

　　串列是 Python 中最基本的資料結構，串列中的每個值都有對應的位置值，稱之為索引，索引以0開始，串列都可以進行的操作包括索引，切片，加，乘，檢查成員，它可以作為一個方括號內的逗號分隔值出現，串列的資料項不需要具有相同的型別

創建

1 list = [1,2,3,4,5]
2 list1 = [7,8,9,10,11]

查詢：從左往右下標是0開始，從右往左下標是1開始

1 print(list1[0])
2 print(list1[-2])
3 print(list1[1:4])

修改：對串列的資料項進行修改，也可以使用 append() 方法來追加串列項

1 list1[2] = 11
2 print(list1[2])
3 list1.append(6)
4 print(list1)

洗掉：使用 del 陳述句來洗掉串列的的元素

1 del list1[2]
2 print(list1)

串列運算子：+ 號用于組合，* 號用于重復串列

 1 # 查詢串列長度
 2 print(len(list1))
 3 #組合串列lise和list1
 4 print(list2+list1)
 5 #重復list
 6 print(list1 * 4)
 7 #判斷元素是否存在串列中
 8 print(3 in list1)
 9 #迭代
10 for i in list1:print(i,end="")

串列截取與拼接

1 #讀取第三個元素
2 print(list1[2])
3 #從右往左讀取第三個元素
4 print(list1[-3])
5 #輸出第三個元素開始后的所有元素
6 print(list1[2:])

嵌套串列：在串列里創建其他串列作為元素，

1 x=[list2,list1]
2 print(x)

串列函式

 1 #查詢串列長度
 2 print(list1)
 3 #查詢串列元素最大值
 4 print(max(list1))
 5 #查詢串列元素最小值
 6 print(min(list1))
 7 #將元組轉化為串列
 8 a = (12,13,14,15,)
 9 a = list(a)
10 print(a)

串列方法

 1 #在串列末尾添加新元素
 2 list1.append(21)
 3 #統計串列中某個元素的個數
 4 list1.count(2)
 5 #在串列末尾添加另一個序列的元素
 6 list1.extend(list2)
 7 #從串列中找出某個值第一個匹配的索引
 8 list1.index(21)
 9 #將物件插入串列的索引3的位置
10 list1.insert(3,23)
11 #移除串列的一個元素，默認最后一個，也可以設定索引選擇，并回傳該元素
12 list1.pop([1])
13 #洗掉串列中某元素的第一匹配項
14 list1.remove(1)
15 #反向串列中的元素
16 list1.reverse()
17 #對原串列進行排序reverse = True 降序， reverse = False 升序（默認）
18 list1.sort(reverse=True)
19 #清空串列元素
20 list1.clear()
21 #復制串列
22 list2.copy()

tuple

　　元組是不可變型別，使用小括號( )

創建：

1 tup1 = (1,2,3,4,5)
2 tup2 = ('a','b','c','d','f')
3 # 當元組只有一個元素時，需要在元素后面添加逗號
4 tup3 = ('year',)

查詢：使用索引查詢元組中的元素

1 print(tup1[0])
2 print(tup1[1:3])

修改：元組是不可變型別，但是允許連接組合

1 tup4 = tup1+tup2
2 print(tup4)

洗掉：元組中的元素不允許洗掉，但是可以洗掉整個元組

1 del tup3

運算子：和串列一樣，元組之間也是可以用 + 號和 * 號進行運算，

 1 # 查詢元組長度
 2 len(tup1)
 3 # 元組連接
 4 tup3 = tup1+tup2
 5 # 復制元組
 6 tup5 = tup1*2
 7 # 查詢元素是否存在元組
 8 print(2 in tup1)
 9 # 迭代
10 for i in tup1:print(i,end="")

索引及截取

1 #讀取第三個元素
2 print(tup1[2])
3 #從右往左讀取第三個元素
4 print(tup1[-3])
5 #輸出第三個元素開始后的所有元素
6 print(tup1[2:])

內置函式

 1 #查詢元組長度
 2 print(len(tup1))
 3 #查詢元組元素最大值
 4 print(max(tup1))
 5 #查詢元組元素最小值
 6 print(min(tup1))
 7 #將串列轉化為元組
 8 a = [12,13,14,15]
 9 a = tuple(a)
10 print(a)

元組不可變是指元組所指向記憶體中的內容不可變

1 # 2322544450056
2 print(id(tup1))
3 tup1 = ('q','w','e')
4 # 2322547972680
5 print(id(tup1))

Dictionary

　　字典是可變型別，可存盤任意型別的物件，字典使用花括號{}，每個對之間以逗號分割，每個鍵值對以冒號：分割，鍵必須是唯一的，不可變的，如字串、數字、元組，但值可修改，表達方式如下：

　　A = {key1 : value1, key2 : value2, key3 : value3 }

創建：

1 wu = {'name':'cloud','age':23,'sex':'male'}
2 zhang = {'name':'Fang','age':18,'sex':'female'}

查詢：用方括號包括需要查詢的鍵

1 print(wu['name'])
2 print(zhang['age'])

修改：添加新的鍵/值對，修改已有的鍵/值對

1 # 添加
2 wu['city'] = 'zhangzhou'
3 # 修改
4 wu['age'] = 24

洗掉：洗掉某個元素或字典，也可清空字典，洗掉之后再次查詢會發生例外

1 # 洗掉單一元素
2 del wu['city']
3 # 清空字典內所有元素
4 wu.clear()
5 # 洗掉這個字典
6 del wu

內置函式

1 # 查詢字典長度
2 len(zhang)
3 # 將字典轉化成字串表示
4 str(zhang)
5 # 查看型別
6 type(zhang)

內置方法

 1 # 清空字典內所有元素
 2 zhang.clear()
 3 # 淺拷貝
 4 zhang.copy()
 5 # 使用序列的值創建新字典
 6 a = ('name','age','sex')
 7 b = 1
 8 wu = dict.fromkeys(a,b)
 9 print(wu)
10 # 回傳鍵對應的值，如果鍵不存在則回傳默認值
11 print(wu.get('name'))
12 print(wu.get('city','xiamen'))
13 # 判斷鍵是否在字典中
14 'city' in wu
15 # 以串列回傳一個視圖物件
16 wu.items()
17 # 回傳一個視圖物件
18 wu.keys()
19 # 鍵存在則回傳，不存在在創建，并且添加默認值
20 wu.setdefault('city','zhangzhou')
21 # 將另一個字典的元素更新到本字典
22 wu.update(zhang)
23 # 回傳值的視圖物件
24 wu.values()
25 # 洗掉鍵對應的值并回傳，否則回傳默認值
26 wu.pop('city',100)
27 # 洗掉字典最后一組鍵值對并回傳
28 print(wu.popitem())

SET

　　集合是一個無序的并且不重復的序列，使用花括號{ }或者set( )創建，創建空集合時需使用set( )，

創建

1 wu = {'cloud',18,'male'}
2 zhang = set('Fang',18,'fimale')

添加：元素可以是數字，字串，串列，元組，字典等，添加時如果元素存在則不進行操作

1 # 添加方式一add()
2 wu.add('zhangzhou')
3 # 添加方式二update()
4 wu.update({6,7})

洗掉

1 # 洗掉方式一remove(),如果元素不存在，則報錯
2 wu.remove({6,7})
3 # 洗掉方式二discard(),元素不存在不會報錯
4 wu.discard(7)
5 # 洗掉方式三pop(),隨即洗掉某個元素
6 wu.pop()

查看集合長度

1 len(wu)

清空集合

1 wu.clear()

判斷元素是否存在

1 'zhangzhou' in wu

內置方法

 1 # 添加元素
 2 wu.add('red')
 3 # 洗掉所有元素
 4 wu.clear()
 5 # 拷貝
 6 wu.copy()
 7 # 回傳wu中不存在zhang的差集
 8 wu.difference(zhang)
 9 # 洗掉wu中存在zhang的元素
10 wu.difference_update(zhang)
11 # 洗掉集合中的指定元素，元素不存在不會發生錯誤
12 wu.discard('red')
13 # 回傳多個集合的交集，回傳一個新集合
14 wu.intersection(zhang)
15 # 在原集合上回傳多個集合的交集
16 wu.intersection_update(zhang)
17 # 判斷兩個集合是否包含相同的元素，如果沒有回傳 True，否則回傳 False
18 wu.isdisjoint(zhang)
19 # 判斷集合是否是另一集合的子集，如果是則回傳 True，否則回傳 False
20 wu.issubset(zhang)
21 # 判斷集合是否是另一集合的父集，如果是則回傳 True，否則回傳 False
22 wu.issuperset(zhang)
23 # 隨機洗掉某個元素
24 wu.pop()
25 # 洗掉指定元素
26 wu.remove('red')
27 # 回傳一個新集合，包含指定兩個集合的差集
28 wu.symmetric_difference(zhang)
29 # 在a集合上洗掉與b集合的交集，并添加b集合的差集
30 wu.symmetric_difference_update(zhang)
31 # 回傳兩個集合的并集
32 wu.union(zhang)
33 # 添加新元素
34 wu.update('Feng')

運算子

Python提供7種運算子：

• 算術運算子
• 比較（關系）運算子
• 賦值運算子
• 邏輯運算子
• 位運算子
• 成員運算子
• 身份運算子

運算子優先級從高到低：（**）>>>（~、+、-）>>>（*、/、%、//）>>>（+、-）>>>（>>、<<）>>>（&）>>>（^、|）>>>（<=、<、>、>=）>>>（==、!=）>>>（=、%=、/=、//=、-=、+=、*=、**=）>>>（is、is not）>>>（in、not in）>>>（not、and、or）

算術運算子

 1 a = 10
 2 b = 2
 3 c = 0
 4 # 加 +
 5 c = a + b
 6 # 減 -
 7 c = a - b
 8 # 乘 *
 9 c = a * b
10 # 除 /
11 c = a / b
12 # 取模 %
13 c = a % b
14 # 冪 **
15 c = a ** b
16 # 整除 //
17 c = a // b

比較運算子

 1 a = 10
 2 b = 2
 3 
 4 # 等于 ==
 5 if a == b:
 6     print('等于 ==')
 7 # 不等于 ！=
 8 else:
 9     print('不等于 ！=')
10 
11 # 大于 >
12 if a > b:
13     print('大于 >')
14 # 小于 <
15 else:
16     print('小于 <')
17 
18 # 大于等于 >=
19 if a >= b:
20     print('大于等于 >=')
21 # 小于等于 <=
22 else:
23     print('小于等于 <=')

賦值運算子

 1 # 賦值 =
 2 a = 10
 3 b = 0
 4 # 加法賦值 +=
 5 b += a
 6 # 減法賦值 -=
 7 b -= a
 8 # 乘法賦值 *=
 9 b *= a
10 # 除法賦值 /=
11 b /= a
12 # 取模賦值 %=
13 b %= a
14 # 冪賦值 **=
15 b **= a
16 # 取整除賦值 //=
17 b //= a
18 # 海象運算子 :=  python3.8版本之后才有
19 if (c := len(a)) > 10:
20     print(c)

位運算子：把數字轉為二進制進行計算

 1 a = 10
 2 b = 7
 3 c = 0
 4 # 與運算：相應位都為1，則為1否則為0 &
 5 c = a & b
 6 # 或運算：相應位有一個1，則為1否則為0 丨
 7 c = a | b
 8 # 異或運算：相應位不同時為1，不同為0 ^
 9 c = a ^ b
10 # 取反運算：對資料進行按位取反，1變0，0變1 ~
11 c = ~a
12 # 左移運算：二進制位左移若干位，高位丟棄，低位補零 <<
13 c = a << 4
14 # 右移運算：二進制位右移若干位 >>
15 c = a >> 3

邏輯運算子

 1 a = 0
 2 b = 5
 3 
 4 # 布爾與:兩個為true輸出true，否則為false  and
 5 if (a and b):
 6    print(True)
 7 else:
 8    print(False)
 9 # 布爾或:一個為true輸出true，否則為false  or
10 if (a or b):
11    print(True)
12 else:
13    print(False)
14 # 布爾非:如果為true輸出false,否則為true  not
15 if not(a and b):
16    print(False)
17 else:
18    print(True)

成員運算子

 1 a = [1,2,3,4,5]
 2 b = 11
 3 c = 2
 4 
 5 # in 如果指定值在序列中回傳true,否則回傳false
 6 if ( c in a ):
 7    print(True)
 8 else:
 9    print(False)
10 # not in 如果指定值不在序列中回傳true,否則回傳false
11 if ( b not in a ):
12    print(True)
13 else:
14    print(False)

條件控制：

 1 name = input('請輸入用戶名：')
 2 
 3 if name == "wu":
 4     print("超級管理員")
 5 elif name == "zhang":
 6     print("普通管理員")
 7 elif name == "cloud":
 8     print("業務主管")
 9 else:
10     print("普通用戶")

回圈陳述句

　　Python提供了兩個回圈陳述句功能for和while

While：如果條件為True,則執行

1 # while
2 sum = 0
3 while sum < 10:
4     print("{}小于10".format(sum))
5     sum += 1

無限回圈：運算式永遠為True

1 # while
2 sum = 0
3 while sum < 10:
4     print("Hello,Word!!!")

While + else陳述句：當條件為false時，執行else陳述句

1 sum = 0
2 while sum < 10:
3     print("{}小于10".format(sum))
4     sum += 1
5 else:
6     print("{}等于10！".format(sum))

for:通常用于遍歷可迭代物件，如串列，字串等

1 # for
2 wu = ['cloud',23,'male','zhangzhou']
3 for i in wu:
4     print(i)

break：結束回圈

1 # break
2 a = 0
3 while a<10:
4     if a == 5:
5         break
6     a += 1
7     print('{}小于10！'.format(a))

Continue：跳出本次回圈

1 # continue
2 a = 0
3 while a <= 10:
4     a += 1
5     if a == 5:
6         continue
7     print('當前回圈值為{}'.format(a))

迭代器

迭代器是一個可以記住遍歷的位置的物件，迭代器物件從集合的第一個元素開始訪問，迭代器只能往前不會后退，一次只取一個元素，同時記錄取值位置，下一個元素如果存在，則取出，如果不存在，則報例外 StopIteration，迭代器有兩個基本的方法：iter() 和 next()，

1 li = [1,2,3,4,5]
2 # 創建迭代器
3 it = iter(li)
4 # 輸出迭代器的下一個元素
5 print (next(it))
6 print (next(it))

生成器

yield 的函式被稱為生成器（generator），生成器只能用于迭代，可以簡單理解為生成器就是一個迭代器，在呼叫生成器運行的程序中，每次遇到 yield 時函式會暫停并保存當前所有的運行資訊，回傳 yield 的值, 并在下一次執行 next() 方法時從當前位置繼續運行，對于生成器只有使用時才創建，從而避免記憶體浪費，

 1 # -*- coding:utf-8 -*-
 2 # @Author:Wu FengYun
 3 
 4 import sys
 5 
 6 
 7 # 生成器函式 - 斐波那契
 8 def fibonacci(a):
 9     b, c, counter = 0, 1, 0
10     while True:
11         if (counter > a):
12             return
13         yield b
14         b, c = c, b + c
15         counter += 1
16 
17 
18 # f 是一個迭代器，由生成器回傳生成
19 f = fibonacci(20)
20 while True:
21     try:
22         print(next(f), end=" ")
23     except StopIteration:
24         sys.exit()

標籤：Python

上一篇：一款 Python 神器搞定自動化圖表配色

下一篇：Python代碼閱讀（第16篇）：串列求差集