Python基礎（粗略整理，筆者會持續更新）

輸出函式print

print(520) # 可以輸出數字
print(98.5) 

print("String")
str4_ = "We all know that 'A' and 'B' are two capital letters." # 輸出字串，沒毛病，單雙都可
print(3+1) # 輸出帶運算子運算式

#可以輸入到指定的檔案
fp = open('S:/test.txt','a+') # 注意不是反斜杠，這個檔案操作真的簡單 a+ 以為不存在則創建，存在則追加
print("hello world",file=fp)# 注意要加file = *
fp.close

#不進行換行輸出，寫在一行？？？

轉義字符

• \t 制表符以四個字符為單位，可以理解為補齊空格，所以才能制表嘛，會出現1、2、3、4=個空格，即是否重開制表位問題，
• 原字符 在字串前加個r或R

r"Hello\nworld" #字串最后一個字符不能是反斜線

識別符號和保留字

保留字查看的方法：

import keyword
print（keyword.kwlist）

識別符號規則基本一致

變數的定義和使用

• 變數的定義：

  變數名 = *

  name = “miao”
  

• 變數的組成：
  標識，型別和值分別可以通過內置函式id(),type(),以及其本身獲得
  所以都是參考變數呢

• 多次復制之后，變數名會指向新的空間， 沒有被指向的會成為垃圾

資料型別

• 不帶小數的都叫int

• 帶小數的都叫float

  浮點數的計算輸出因為存盤方式問題會存在結果容易出問題的問題，

  用decimal（）解決，

• True和Fale分別是0 1

• 字串，不解釋

  稱為不可變的字符序列

  ‘單引號’ “雙引號” “”"“三引號”"" 其中單雙必須在一行，三可以隨意

print(str,type(str)) # 直接逗號分隔，，，

型別轉換

str( )函式

懂得都懂，可以講括號里面的轉成字串

int( )

float( )

不多BB

input( )函式

enter = input('輸入提示')

型別轉換

int(enter)

基本運算

算術運算子

• 除法運算 /

  1/2 = 0.5

• 整除運算

  11//2 = 5

• 冪運算 **

  2**2 = 4

• 一正一負的整除和取余

  一正一負的整除向下取整

  9//-4 = -3

  余數 = 被除數-出書*商

  9%-4 = -3 -9%4 = 3

賦值運算子

• 運算順序從右到左
• 支持鏈式賦值

a=b=c=20 # 記憶體地址相同，懂得都懂

• 引數賦值

a+=30 #等一系列操作

• 系列解包賦值

a,b,c = 10,20,30

比較運算子

• 比較運算的結果時Bool型別
• == 比較的是物件的值
• is運算子比較的是物件的標識（地址，id）is not 不解釋

Bool運算子

• and -> &&
• or ||
• not !
• in 在不在,可以~ 同樣的還有 not in

s = "hello world"
"w" in s 

程式的bool值

內置函式bool()

• 布林值位False：False、數值（）、None、空字串、空串列、空元組、空字典、空集合

程式的組織結構

順序、回圈、選擇

順序結構

從上到下，依次執行

選擇結構

根據bool值判斷陳述句是否執行

• 單分支結構：

  if num>=n : # (num>=n) 這么些也是可以的
      print("我說可以~")
  

• 雙分支結構：

if(num>=n)

• 多分支結構：

if num>n:
    print("ky")
elif num==n:
	print("ky")
else:
    printf("gun")
    

• 分支結構之間允許出現嵌套

• if else 簡寫，類似于三目運算子

  x if condition else y

pass陳述句

• 陳述句什么都不做，只是一個占位符，用在語法上需要陳述句的地方

if(a>b):
    pass # 用于構建陳述句

回圈結構

range()函式

• 用于生成一個整數序列
• 創建方式：

# 一參,范圍，但是不包括右區間點
r = rang(10) # 回傳結果是一個迭代器物件，默認從0開始，默認相差1
list(r) # list 生成一個串列，用于存盤迭代器物件序列

# 二參，指定了起始值
range(1,10)

# 三參，起始值，結束值，步長
range(1,10,2)

• 可以使用in和not in來進行bool運算
• 物件只儲存三個值，占記憶體空間較小，很靈活，再用到range時才會產生相關的序列

while

while condition:

? sentence

• 初始化變數
• 條件判斷
• 執行陳述句
• 改變變數

for-in

for var in iterableOBJ:

? sentence

• 通常用序列和字串去作為可迭代物件

• 用不到變數的話可以用 _ 替代

for _ in range(5):
    print("wo tu le ")

break 和 continue

• 直接寫就完了

break
continue

else 在回圈中

• else寫在回圈之后，如果回圈執行程序中沒有遇到break那么之心完畢之后會執行else

for item in range(5):
    print("Hello!")
    if(item==5):
        break
else:
    print("word")

串列—陣列

• id,type,value

串列的創建

• 方括號

  list = ["hello","world"]
  

• 使用內置函式list

  list = list(["hello","world",321]) # 混合型別，，，
  

串列的特點

• 串列元素有序排列
• 索引銀蛇第一個資料
• 串列可以存放重復資料
• 任意資料型別混合存盤
• 根據需要動態的分配和回收記憶體

list的元素獲取

獲取單個元素

• 通過index( )函式

  list.index("str") # 回傳第一個匹配的索引，不存在則拋出例外
  list("str",star,end) # 回傳區間內的索引
  

• 通過索引去獲得元素

  list[2] # 正向獲取 0~n-1 ,n為元素個數
  list[-3] # 逆向獲取 -n~-1
  

獲取多個元素

• 切片操作，同樣不包括stop

  • list_name[star:stop:step]

  • step默認為1，可簡寫為[star:stop]

  • step為正數，從star開始往后計算切片；為負數則從star往前擠蒜切片

  • step，步長，1無間隔，2間隔1……

遍歷

for-in,天生的迭代器

串列元素的添加

• append( )，追加

• extend( ),在串列的末尾至少添加一個元素，對于串列的操作

• instet( )，任意位置插入

• 切片，任意位置至少添加一個元素

  list[1:] = list3 # 從第一個元素開始切掉后面的，把list3接到后面
  

串列元素的洗掉

• remove( )

  • 一次洗掉一個元素
  • 重復元素只洗掉第一個
  • 不存在元素拋出例外

• pop( )

  • 洗掉一個指定索引的元素
  • 不存在拋出例外
  • 沒有指定索引洗掉最后一個，有出堆疊那味兒了

• 切片

  • 一次至少洗掉一個唄

• clear( )

  • 清空表

• del

  • 洗掉表

    del list # 洗掉物件
    

串列元素的修改

• 為指定的元素賦予一個新值
• 為指定切片賦予一個新值，切下來一塊，補充上去，不在乎長度，自動擴充的

串列的排序操作

• sort( )方法

  • 默認進行升序排序，內部有引數reserve=True可以進行降序

• 內置函式sorted

  • 會產生一個新的串列，需要一個變數去接一下

  串列生成式

• list = [i for i range (star,stop)]

  • i 的位置是表示串列元素的運算式

字典

• Python內置的資料結構之一，與串列一樣是一個可變序列
• 以鍵值對的方式存盤資料，字典是一個無需的序列， 類似于Map
• 地點的實作原理類似于hashMap，由key到value的處理，經過hash函式，所以在記憶體上存盤時無序的，

字典的創建

• 使用花括號

  score = {"zhangsan": 100 , "lisi": 98, "wangwu": 45}
  

• 使用內置函式dict( )

  dict(name = "jack" , age = 20) # 注意，這里的鍵沒有加引號
  

字典元素的獲取

• 用[ ]來獲取

  score["zhangsan"] # 如果字典中不存在對應的值則拋出keyError例外
  

• 用get( )

  score.get("zhangsan") # 如果字典中不存在key，回傳None
  score.get("zhaoliu",bucunzaide) # 可以通過引數設定默認的value，以便指定key不存在時的回傳值
  

字典元素的洗掉

del score["zhangsan"]
score.clear() # 清空整個字典

字典元素的新增

score["jack"] = 90 # 類似的還可以用來修改

獲取字典視圖的三個方法

• keys( )獲取字典中所有的key
• values( )獲取字典中所有的valus
• items( ) 獲取字典中所有的K V對

字典元素的遍歷

for item in score:
    print(score[item]) # item是Key

字典的特點

• 字典中的所有元素都是一個key-value對，key不允許重復，value可以重復
• 字典中的元素是無序的
• 字典中的key’必須是不可變物件
• 字典可以根據需求自動的伸縮
• 字典會浪費較大的記憶體，是一種空間換時間的資料結構

字典生成式

• 內置函式 zip()

  list = zip(item,price) # 可迭代物件作為引數
  print(list)
  

元組和集合

元組

• Python的內置資料結構之以，是一個不可變序列

不可變序列與可變序列

• 不可變序列：包括字串和元組，沒有 增 刪 改 的操作
• 可變序列：串列、字典和集合，可以對序列執行 增 刪 改 操作，物件的地址不發生改變

元組的創建

• 小括號

  t = ("PYTHON","hello",90) t = ("PYTHON",)
  

• 內置函式tuple( )

  t = tuple(("PYTHON","hello",90))
  

為什么設計這個東西？

• 在多任務環境下，同時操作物件時不需要加鎖（根本改不了），使用在程式中盡量使用不可變序列
• 可以動物件的值但是不能動地址

集合

• 與串列和字典一樣屬于可變型別的序列
• 集合時沒有value的字典，資料結構同樣是hash表

集合的創建

• 大括號

  s = {"Python","hello",90}
  

• 使用內置函式set( )

  s = set(range(5))
  s = set({"Python","hello",90})# 括號里面放可迭代的物件
  

集合元素的相關操作

• 新增
  • add( )一次點擊加一個元素
  • update( ) 一次添加至少一個 括號里面放可迭代的物件
• 洗掉
  • remove( )一次洗掉一個指定元素，如果指定元素不存在就拋出KeyError
  • discard( )不拋出
  • pop( )洗掉任意元素，堆疊頂的？
  • clear( )懂得都懂

集合間的關系

• 是否相等用 == 和 != 判斷
• 是否是自己 issubset( )
• 是否是超集 issuperset( )
• 是否有交集 isdisjoint( )

集合的數學操作

• 交集 intersection( ) 或者使用運算子 &
• 并集 union( ) 或者使用運算子 |
• 經過集合操作，地址不發生變化
• 差集 difference( )，或者是運算子 -
• 對稱差集 symmetric_difference( )

集合生成式

{i*i for i range(1,10) }

字串

• 字串在python中時基本資料型別，是一個不可變的字符序列

• 字串的駐留機制，，，

• 字符型的串列，后面的不做贅述，有需要直接查API

• 查詢，大小寫轉換，內容對其劈分，各種判斷（是否合法），替換與合并，比較，切片，格式化，編碼與解碼（用于網路傳輸）

函式

函式的創建和呼叫

def 函式名（[輸入引數]）:

? 函式體

? return xxx

def calc(a,b):
    c = a+b
    return c
result = calc(10,20)

函式呼叫的引數傳遞

• 位置實參，根據形參對應的值進行引數傳遞

• 關鍵字實參，根據形參的名稱景行引數傳遞

  calc(b=10,a=10) # 怎么說呢，感覺很詭異
  

• 引數傳值傳的是地址，可以間接改變value

• 函式定義時，給形參設定默認值，只有與默認值不符的時候才需要傳遞實參

• 個數可變的我位置引數

  • 定義函式時，無法確定傳遞的位置引數的個數時，使用可變的位置引數
  • 使用*定義個數可變的位置引數
  • 引數值會是一個元組

• 個數可變的關鍵字形參

  • 結果為一個字典（），傳的是鍵值對，關鍵字形參本身就是鍵值對er

函式的回傳值

• 函式回傳多個值時，結果為元組

變數的作用域

• 程式代碼能訪問該變數的區域
• 區域變數
  • 在函式內定義并使用的變數，只在函式內部有效，區域變數使用global生命，這個變數就會成為全域變數
• 全域變數
  • 函式體外定義的變數

BUG

面向物件

類

• 不同的資料型別屬于不同的類
• 可以使用內置函式查看資料型別

物件

• 類的實體

類的創建

class student:
    native_place = "taiyuan" # 直接卸載類里面的變數成為類屬性
    def __init__(self,name age): # 初始化方法
        # 在類之外定義的稱為函式，在類內部定義的成為方法
        self.name = name
        self.age = age
    @staticmethod
    def method():
        print("Static method")
    @classmethod
    def cm(cls):
        print("Class method")
        

物件的創建

stu1 = Student("zhangsan",18)
# 實體物件有類指標指向類物件
stu.eat()

類屬性

• 在方法外定義的屬性——在類體內直接定義
• 被所有的該類物件共享，當然，允許修改

類方法

• 使用@classmethod修飾的方法，使用類名可以直接訪問

  Student.cm( )

• 靜態方法同上，修飾有所不同

動態的系結屬性和方法

stu2.gender = "girl" # 直接系結到實體化的物件上
def show():
    print("show ")
    
 stu2.show = show # 完成方法系結

封裝

• 在python中沒有專門的修飾符用于屬性的私有，如果該屬性不希望在類物件的外部被訪問，前面使用兩個“ - “
• 但是仍然可以通過 Objname._ClassName__variable_name 訪問

繼承

• 如果一個類沒有繼承任何類，那么它默認繼承object

• 定義子類是，必須在其建構式中呼叫父類的建構式

  class Student(People):
      def __init__(self,name,age,score):
          super().__init__(name,age)
          self,score = score
  

方法重寫

• 在子類里面把父類的方法重新寫一遍就完了唄，或i用super( ).

object

• object類是所有類的父類，一次所有類都具有object類的屬性和方法
• 內置函式dir( )可以查看指定物件的所有屬性
• _str() 同toString( )

多型

• 你不知道一個變數所參考的物件到底是什么型別，仍然可以通過這個變數呼叫方法，在運行中根據變數所參考物件的型別，動態地決定呼叫哪個物件中的方法

• 靜態語言實作多型的三個條件

  • 繼承
  • 方法重寫
  • 弗雷參考指向子類物件

• 動態語言崇尚”鴨子型別“，當看到一只鳥走起來像鴨子、游泳起來像鴨子，那么這只鳥就可以被稱為鴨子，不關心物件是什么型別，到底是不是鴨子，只關心物件的行為，

• 只要有相關的方法就行，不在乎有沒有繼承關系，0

特殊方法和屬性

 obj.__ dict__ #獲得類物件或者實體物件所有的屬性，回傳值是一個字典
 obj.__class__# 獲得物件所屬的類
 obj__base__ # 獲得物件弗雷的一個元組
 obj.__mro__ # 查看類的繼承結構
 obj.__subclasses__() # 回傳子類的串列

def __init__(self,vars):
    obj.var = var # 用于定義類成員變數及其初始化
__add__() # 運算子多載
__len__() # 定義如何計算長度

模塊化編程

模塊

• Moudles

• 一個模塊可以有很多個函式，類，陳述句什么的，一個py檔案就是一個模塊

• 方便其他程式和腳本的匯入并使用

• 重用性，方便管理

匯入

import math # 匯入數學計算模塊
from  math import pi # 匯入math中的pi