建議有程式語言基礎的童鞋閱讀，零基礎閱讀可能會有點費解

文章目錄

Python基礎知識

註釋方法資料型別輸入和輸出算數運算子常用運算函式比較運算子邏輯運算子成員運算子分支迴圈列表字典（物件）元組集合字串的常用操作函式python異常處理機制類與物件模組和包檔案的讀寫python內建模組註釋方法

# 單行註釋''' 多行註釋 '''

資料型別

檢視資料型別函式type(變數) 返回該變數的資料型別

資料型別轉換函式int(num) 將num轉換為整數型別float(num) 將num轉換為浮點數型別bool(num) 將num轉換為布林型別str(num) 將num轉換為字串型別

注：

int bool float 任何兩種型別都可相互轉換任何型別都可以轉換為字串

注：

str -> int 要求全部為數字str -> float 要求全部為數字，且可存在一個小數點

注：當布林值False轉換為str後， 在轉換為bool會變成True

輸入和輸出輸入

語法 inp = input('提示文字')

注：輸入結果為str資料型別，如須做其他操作可進行資料轉換

輸出預設輸出

print('hello, world')

佔位符輸出

# %s 的s表示變數的資料型別print('名字：%s，年齡：%s，性別：%s' % (name, age, sex)) 

推薦使用

print(f'名字：{name}，年齡：{age}，性別：{sex}')

算數運算子

+ - * / ** // %

前四個同其他程式語言用法相同

** 表示平方計算 5 ** 2 === 5的2次方// 表示做除運算後取整% 取餘運算

簡寫形式+= -= *= /= **= //+ %=

注：+ 也可用於字串拼接* 當任意一邊為字串時，則表示重複字串

常用運算函式

round(num, count) 表示對num四捨五入，並保留小數點後count位

比較運算子

> < >= <= = !=

常用函式

ord(chr) 返回該chr的ASCII碼(只能為單個字元)chr(num) 返回該ASCII對應的字元邏輯運算子

and ，or ， not

成員運算子

in ，not in

分支

單分支

# 注意縮排if bool表示式:      print('執行')  

雙分支

# 注意縮排if bool表示式:      print('執行語句1')  else:    print('執行語句2')

分支巢狀

# 注意縮排if bool表示式:      if bool表示式2:        print('執行巢狀語句')    else:        print('執行語句1')  else:    print('執行語句2')

多分支

# 注意縮排if bool表示式1:      print('執行語句1')  elif bool表示式2:    print('執行語句2')elif bool表示式...:    print('執行語句...')else:     print('如上都不滿足，則執行這條語句')

迴圈

迴圈控制

只能在迴圈語句中使用，只對距離最近的迴圈起作用

break # 跳出本迴圈continue # 結束本次迴圈，執行下一次迴圈 

while迴圈

# 注意判斷條件while bool表示式:    print('執行語句')

for迴圈

# range(start, end, rule) 從start開始，到end-1，間隔為rule,rule的正負表示正序或倒序# range(1, 11) 輸出1~10，不包括最大值11# range(1, 11, 2) 輸出1~10，不包括最大值11, 第三個引數表示為每次間隔2# range(11, 1, -2) 輸出11~2，不包括最小值值1, 第三個引數為負數，則表示為倒序且每次間隔2# range(5) 簡寫形式，0~5的範圍for i in range(1,11):    print(i)

迴圈else結構

只有迴圈完整執行完畢後，才會執行else語句當迴圈過程中執行break語句後，else將不執行

# while  while bool表示式:      print('執行語句')else:    print('while  else語句')    # for  for i in range(10):      print('執行語句')else:    print('for  else語句')

列表

物件是儲存單個數據的容器，而列表（陣列）就是儲存多個數據的容器，任何資料型別都可以存放

# 字面量建立新列表lst = [1,'2','三']# 使用list函式建立新列表lst = list([1,'2','三'])

列表的取值透過索引下標取值使用for迴圈獲取元素的下標list.index(‘元素’) 找不到元素則丟擲異常， 可預先使用in方法判斷是否存在獲取列表中多個元素（切片）

list[start:end:step]從start索引位置開始，擷取到end-1位置結束，步長為step

其中step可為負值，表示從start位置往左邊擷取開始

start預設值為0end預設值為列表長度step預設值為1

省略引數但 : 必須存在 list[::]

列表的增刪改操作增加append(item)在原有的列表末尾新增一個元素

lst = [10, 20, 30] lst.append(100)print(lst) # [10, 20, 30, 100] 

extend( [] )在原有的列表末尾至少新增一個元素，新增元素必須是列表（新增多個）

lst = [10, 20, 30] lst.extend([99, 100])print(lst) # [10, 20, 30, 99, 100] 

insert(index, item)在原有的列表指定位置新增一個元素

lst = [10, 20, 30] lst.insert(1, 99)print(lst) # [10, 99, 20, 30] 

切片新增多個元素(指定位置新增多個元素)使用切片把選擇到的元素替換掉

lst = [10, 20, 30] lst[1:] = [99]print(lst) # [10, 99]

刪除remove(item)在原有的列表刪除一個元素，如果有重複元素只刪除一個，如果元素不存在則丟擲異常

lst = [10, 20, 30] lst.remove(20)print(lst) # [10, 30] 

pop(index)刪除指定索引位置的元素，如果指定索引不存在則丟擲異常不傳index，則刪除末尾元素

lst = [10, 20, 30] lst.pop(1)print(lst) # [10, 30] 

clear()清空列表

lst = [10, 20, 30] lst.clear()print(lst) # []  

切片刪除元素使用切片把選擇到的元素替換為空

lst = [10, 20, 30] lst[1:] = []print(lst) # [10]

刪除列表，即釋放記憶體（謹慎使用）

lst = [10, 20, 30] del lstprint(lst) # 會丟擲異常， lst is not defined

修改直接重新賦值

lst = [10, 20, 30] lst[1] = 40print(lst) # [10, 40, 30]  

切片修改（批次修改）

lst = [10, 20, 30] lst[1:3] = [40, 50, 60]print(lst) # [10, 40, 50, 60]  

列表的排序sort()在原列表的基礎上排序傳入reserse=True降序排序傳入reserse=False生序升序不傳預設升序

# sotr()  lst = [9, 3, 2, 8] lst.sort()  print(lst) # [2, 3, 8, 9]  # sotr(reserse=True)  lst = [9, 3, 2, 8] lst.sort(reserse=True)  print(lst) # [9, 8, 3, 2]# sotr(reserse=False)  lst = [9, 3, 2, 8] lst.sort(reserse=False)  print(lst) # [2, 3, 8, 9]  

sorted(lst[,rule ])使用內建函式sorted()進行排序，將產生一個新列表物件傳入第二引數reserse=True降序排序傳入第二引數reserse=False生序升序不傳第二引數預設升序

# sorted(lst)  lst = [9, 3, 2, 8] new_list = sorted(lst)  print(new_list) # [2, 3, 8, 9]  # sorted(lst, reserse=True) lst = [9, 3, 2, 8] new_lsit = sorted(lst, reserse=True)  print(new_list) # [9, 8, 3, 2]# sorted(lst, reserse=False)  lst = [9, 3, 2, 8] new_lsit = sorted(lst, reserse=False)   print(new_list) # [2, 3, 8, 9]  

列表生成式[i for i in renge(1, 11)]列表生成的表示式

lst = [i*i for i in renge(1, 6)]print(lst) # [1, 4, 9, 16, 25]

列表常用函式len(list)：列表元素個數max(list)：返回列表元素最大值min(list)：返回列表元素最小值字典（物件）

python的內建資料結構之一，以鍵值對的方式儲存資料。在其他語言中也叫物件。

字典的建立方式info = {'name':'zzl', 'age':18}info = dict(name='zzl', age=18)字典的常用操作獲取字典中的元素

info = {'name':'zzl', 'age':18}  # []方式print(info['name']) # zzl  print(info['sex']) # error: keyError # get()方式print(info.get('name')) # zzlprint(info.get('sex')) # None  print(info.get('sex', '男')) # 如果sex欄位為None的話，則列印 '男' 預設值

key的判斷in, not in

info = {'name':'zzl', 'age':18}  # inprint('name' in info) # True  # not inprint('sex' nor in info) # True

key的刪除

info = {'name':'zzl', 'age':18}  del info['name'] # 刪除name欄位print(info) # {'age':18}info.clear() # 清空該字典  print(info) # {}

新增key

info = {'name':'zzl', 'age':18}  info['sex'] = '男'print(info) # {'name':'zzl', 'age':18, 'sex':'男'}  

修改key

info = {'name':'zzl', 'age':18}  info['age'] = 20print(info) # {'name':'zzl', 'age':20}  

獲取字典的試圖方法keys()返回字典的所有key組成的列表

info = {'name':'zzl', 'age':18}  keys = info.keys()print(keys) # ['age', 'name']

values()返回字典的所有value組成的列表

info = {'name':'zzl', 'age':18}  values = info.value()print(values) # [18, 'zzl']

items()返回字典的所有key:value組成的列表

info = {'name':'zzl', 'age':18}  itmes = info.items()print(items) # [('age', 18), ('name', 'zzl')]

字典的遍歷

info = {'name':'zzl', 'age':18}  for item in info:    print(item，info[item])# age 'zzl'# name 18

字典的生成式

items = ['Fruits', 'Books', 'Others'] prices = [98, 97, 95] d = { item:price for item, price in zip(items, prices) }print(d) # {'Others': 95, 'Books': 97, 'Fruits': 98}

字典的特點

字典中的所有元素都是一個key-value對，key不允許重複，value可以重複字典中的元素是無序的字典中的key必須是不可變物件，（即key不能為變數）字典也可以根據需要動態的伸縮字典會浪費較大的記憶體，是一種使用空間換時間的資料結構元組

列表的另一種形式，是不可變序列

元組的建立方式

# 直接用小括號書寫t = ('python', 'world', '20') # 使用內建函式tuple() t1 = tuple( ('python', 'world', '20') )t3 = ('python',) # 如果元組只有一個元素，則在元素後面加上 ，  # 獲取元組的元素t[0] # python

元組的遍歷

t = ('python', 'world', '20') for item in t:    print(item)# python# world # 20

注：

如果元組中物件本身是不可變物件，則不能再引用其他物件如果元組中的物件是可變物件，則可變物件的引用不允許改變，但資料可以改變集合

python語言提供的內建資料結構與列表、字典都屬於可變型別的序列集合是沒有value的字典集合的儲存是無序的

集合的建立

# 集合的value不能重複s = {2, 3, 4, 5, 2, 4} print(s)  # {2,3,4,5}# set()函式  s1 = set(range(6)) print(s1) # set([0, 1, 2, 3, 4, 5])s2 = set([1,2,3,5,6,4,3])print(s2) # set([1, 2, 3, 4, 5, 6])s3 = set((1,23,5,32,1))print(s3) # set([32, 1, 5, 23])s4 = set('python')  print(s4) # set(['h', 'o', 'n', 'p', 't', 'y'])s5 = set({12,4,23,4,12})  print(s5) # set([12, 4, 23])# 定義集合s6 = set()

集合的常用操作

s = {10, 20, 30, 40, 50}   # 判斷是否存在print(10 in s) # True   print(70 in s) # False# 新增  s.add(80) print(s) # {10, 20, 30, 40, 50, 80}  # 新增多個  s.update({200, 400})  print(s) # {10, 20,, 200, 30, 40, 50, 400, 80}  # 刪除  s.remove(10) print(s) # {20,, 200, 30, 40, 50, 400, 80} s.remove(900) # error: keyErrors.discard(900) # 如果有則刪除900， 沒有也不會報錯s.pop() # 隨機刪除一個， 不能傳參  s.clear() # 清空集合

集合間的關係

兩個集合是否相等（判斷集合中的元素是否完全相等）

s1 = {10, 20, 30, 40}s2 = {20, 40, 10, 20} print(s1 == s2) # Trueprint(s1 != s2) # False

一個集合是否是另一個集合的子集

假如集合s1的元素裡包括集合s2的全部元素，則s2是s1的子集

s1 = {10, 20, 30, 40}s2 = {20, 40} print(s2.issubset(s1)) # True

一個集合是否是另一個集合的超集

與上相反，假如集合s1的元素裡包括集合s2的全部元素，則s1是s2的超集

s1 = {10, 20, 30, 40}s2 = {20, 40} print(s1.issuperset(s2)) # True

一個集合和另一個集合是否無交集

如果一個集合裡某個元素，在另一個集合裡也有儲存，則兩個集合有交集

s1 = {10, 20, 30, 40}s2 = {80, 60} print(s1.isdisjoint(s2)) # False 無交集

字串的常用操作字串的查詢操作方法字串的大小寫轉換操作的方法字串內容對齊操作的方法字串分割操作的方法判斷字串操作的方法字串操作的其他方法字串格式化操作

# %s 的s表示資料型別  s:字串  i:整數print('我叫%s，我今年%i歲' % ('zzl', 18)) # 我叫zzl，我今年18歲'# {}裡的數字表示後面變數的索引，可重複使用print('我叫{0}，我今年{1}歲，我真的叫{0}'.format('zzl', 18)) # 我叫zzl，我今年18歲，我真的叫zzl'# 前面加f  可在{}中直接填寫變數print(f'我叫{'zzl'}，我今年{18}歲') # 我叫zzl，我今年18歲'

字串編碼和解碼操作

# 編碼s = '好好學習，天天向上'# 使用GBK格式進行編碼, 此格式中，一箇中文佔兩個位元組print(s.encode(encoding='GBK')) #b'\xba\xc3\xba\xc3\xd1\xa7\xcf\xb0\xa3\xac\xcc\xec\xcc\xec\xcf\xf2\xc9\xcf'# 使用UTF-8格式進行編碼 此格式中，一箇中文佔三個位元組print(s.encode(encoding='UTF-8')) #b'\xe5\xa5\xbd\xe5\xa5\xbd\xe5\xad\xa6\xe4\xb9\xa0\xef\xbc\x8c\xe5\xa4\xa9\xe5\xa4\xa9\xe5\x90\x91\xe4\xb8\x8a'# 解碼  （使用什麼格式編碼，就必須使用什麼格式解碼，否則會報錯）# 使用GBK格式進行編碼print(s.encode(encoding='GBK').decode(encoding='GBK')) # 好好學習，天天向上# 使用UTF-8格式進行編碼print(s.encode(encoding='UTF-8').decode(encoding='UTF-8')) # 好好學習，天天向上

函式函式的定義和使用

# 定義def 函式名(a, b): # 引數a和b    函式體      return  # 返回值      # 使用  函式名()  # 程式碼演示  def cals(a, b):    c = a + b     return c    res = cals(20, 30) # 50  

函式的引數傳遞

位置傳參，cals(20, 30) ，此時a的值是20， b的值是30關鍵字傳參， cals(b=70, a=30) 此時a的值是30， b的值是70函式的返回值如果函式沒有返回值（函式執行完畢之後，不需要給呼叫處提供資料）,return可以省略不寫函式的返回值，如果是1個，直接返回原值函式的返回值，如果是多個，返回的結果為元組

def fun(lst):    odd = [] # 存放奇數      even = [] # 存放偶數    for i in lst:        if (i%2) :            odd.append(i)        else:            even.append(i)    return odd,evenlst = [10, 23, 65, 78, 32, 77] print(fun(lst)) # ([23, 65, 77], [10, 78, 32])

函式的預設值

在定義函式的時候，可以給形參賦上預設值，當沒傳引數的時候，函式會取預設值，如果傳參和預設值同時存在，傳的引數會替換掉預設值

def cals(a, b = 10):    c = a + b     return c    res = cals(20) # 30  res = cals(20, 30) # 50

函式的引數定義個數可變的位置引數定義函式時，可能無法確定傳遞的實參個數，這個時候就要使用可變的位置形參。使用*定義，結果為一個元組

def fun(*args);    print(args)fun(1)  # (1,)fun(1,2,3)  # (1, 2, 3)

個數可變的關鍵字引數（指定引數名傳遞引數）定義函式時，可能無法確定傳遞的關鍵字實參個數，這個時候就要使用可變的關鍵字形參。使用*定義，結果為一個字典

def fun(**args);    print(args)fun(a=10)  # {'a':10}fun(a=10, b=20, c=30)  # {'a':10, 'b':20, 'c':30}

以上引數在函式定義時，一種方式只能定義一次。當兩種引數定義方式同時存在時，位置形參必須在關鍵字形參前面

python異常處理機制異常捕獲

try:    可能出現異常的語句放在這裡 except 你要捕獲的異常型別:    捕獲到異常後你想做什麼except 你要捕獲的異常型別:    捕獲到異常後你想做什麼...except BaseException as e: # 這種情況是以上異常型別都沒捕獲到，則執行這塊程式碼    print('出錯了', e)print('程式照常執行')

異常捕獲else

try:    可能出現異常的語句放在這裡 except 你要捕獲的異常型別:    捕獲到異常後你想做什麼except 你要捕獲的異常型別:    捕獲到異常後你想做什麼...except BaseException as e: # 這種情況是以上異常型別都沒捕獲到，則執行這塊程式碼    print('出錯了', e)else:    print('如果沒有異常則執行else部分')

try…except…else…finally結構

try:    a = int(input('請輸入第一個整數'))    b = int(input('請輸入另一個整數'))    res = a/bexcept BaseException as e:    print('出錯了', e)else:    print('結果為:'res)finlly:    print('無論是否產生異常，總會被執行的程式碼')

python常見的異常型別類與物件類的建立類屬性: 類中方法外的變數稱為類屬性，被該類的所有例項物件共享類方法: 使用@classmethod修飾的方法，可使用類名直接訪問靜態方法: 使用@staticmethod修飾的方法，可使用類名直接訪問

# Stubent為類的名稱，由一個或多個單片語成。（建議類名書寫方式為每個單詞首字母大寫）class Student:    native_pace = '河南' # 直接寫在類裡的變數，稱為屬性        # 初始化函式( 建構函式 )    def __init__(self, name ,age):        # 建立例項的時候 對name和age屬性進行賦值        self.name = name        self.age = age        # 定義在類裡面的方法為例項方法    def eat(self):        print('吃飯')        # 靜態方法 （靜態方法裡不允許寫self）    @staticmethod     def method():        print('使用staticmethod進行修飾，所以我是靜態方法')                    # 類方法    @classmethod     def cm(cls):        print('使用calssmethod進行修飾，所以我是類方法')    

類例項物件

# 類例項建立語法  stu = Student()# 假設已存在上面的 Student 類  # stu1就是Student類的例項物件，該例項物件中可以訪問到類中的屬性和方法stu1 = Student('zzl', 18) # 建立例項print(stu1.name) # zzlprint(stu1.age) # 18stu1.eat() # 吃飯

動態繫結屬性和方法

# 假設已存在Student類  stu = Student('zzl', 18)  # 繫結 gender 屬性 stu.gender = '男' print(stu.gender) # 男# 繫結 show 方法def show():    print('show方法執行')stu.show = showstu.show() # show方法執行

面向物件的三大特徵封裝 （提高程式的安全性）將資料（屬性）和行為（方法）封裝到類物件中，在方法內部對屬性進行操作，在類物件的外部呼叫方法。這樣無需關心方法內部的具體實現細節，從而隔離了複雜度。在python中沒有專門的修飾符使用者屬性的私有化，如果該屬性不想被類物件訪問，可以在屬性名前面加兩個 ‘_’繼承多型

程式碼演示

# 繼承class Person(object):    def __init__(self, name, age):        self.name = name        self.age = age    def info(self):        print(self.name, self.age)class Student(Person):    def __init__(self, name, age, stu_no):        super().__init__(name, age)        self.stu_no = stu_noclass Teacher(Person):    def __init__(self, name, age, teachofyear):        super().__init__(name, age)        self.teachofyear = teachofyearstu = Student('張三', 20, 10001)teacher = Teacher('李四', 35, 10)stu.info() # 張三 20teacher.info() # 李四 35# python 支援多繼承 class A(class1, class2):      pass    # 方法重寫  # 方法重寫就是在子類裡定義與父類重名的方法，這樣就會優先呼叫子類的定義的方法

模組和包

定義：每一個.py檔案就是一個模組

使用模組化的好處

方便其他程式和指令碼的匯入使用避免函式名和變數名衝突提高程式碼的可維護性提高程式碼的可重用性匯入模組

# 匯入模組import 模組名稱 [as 別名]  # 匯入模組中的指定函式(or 變數 or 類)from 模組名稱 import 函式/變數/類

包

包是一個分層次的目錄結構，它將一組功能相近的模組組織在一個目錄下

作用

程式碼規範避免模組名稱衝突

包與目錄的區別

包含__init__.py檔案的目錄稱為包目錄裡通常不存在__init__.py檔案

包的匯入import 包名.模組名

檔案的讀寫內建函式open()建立檔案物件

# file = open( filename, [mode, encoding] )# 假設有一個名為a的文字檔案，裡面有hello worldfile = open('a.txt', 'r')print(file.readlines()) # ['hello world']file.close()

常用的檔案開啟模式檔案物件的常用方法with語句（上下文管理器）

with語句可以自動管理上下文資源，不論什麼原因跳出with語句都能確保檔案正確的關閉，以此來達到釋放資源的目的

# with使用  with open(filename, mode) as file:    pass 

目錄操作 （os 和 os.path）os模組是python內建的與作業系統功能和檔案系統相關的模組，該模組中的語句的執行結果通常與作業系統有關，在不同的作業系統上執行，得到的結果可能不一樣os模組與os.path模組用於對目錄或檔案進行操作

import os# 開啟計算器os.system('calc.exe')# 開啟記事本os.system('notepad.exe')# 開啟可執行檔案os.startfile('路徑')

os模組操作目錄相關函式

os.path模組操作目錄相關函式

python內建模組

使用import關鍵字引入

感謝閱讀！！！

多說一句，很多人學Python過程中會遇到各種煩惱問題，沒有人解答容易放棄。小編是一名python開發工程師，這裡有我自己整理了一套最新的python系統學習教程，包括從基礎的python指令碼到web開發、爬蟲、資料分析、資料視覺化、機器學習等。想要這些資料的可以關注小編，並在後臺私信小編：“01”即可領取。