自然語言用雙引號,機器語言用單引號 例如dict的key

單行註釋 #

多行註釋 ''' '''

輸入print

%s 字串的佔位符

%d 數字的佔位符

如語句中有佔位符那麼所有的%都是佔位符,可以用%%轉義

n**m n的m次冪

邏輯運算子

• and 並且

• or 或者

• not 非的意思

• 運算順序

  • and or not 同時存在 先算括號然後算not 然後算and 最後算or

  • x or y 如果x==0,那麼就是y,否則就是x,記住and跟or相反,如果x==0,那麼就是x,否則就是y

bit_length() 二進位制的長度

bool() 強制轉化為boolean型別

空的東西都是Flase,非空的東西都是true

切片可以對字串進行擷取

• 語法s[起始位置:結束位置] 包左不包右
• 語法s[其實位置:結束位置:步長] 步長是沒幾個取一個,就是取後一個

字串是不可變的物件,所以任何操作對原字串本身是不會發生改變的

字串操作

capitalize 首字母大寫

lower 全部轉換成小寫

upper 全部裝換成大寫

swapcase 大小寫互相互動位置

title() 單詞的首字母大寫

strip 去掉空格

lstrip 去掉左邊空格

rstrip 去掉右邊空格

split 切割

format 指定位置的索引 {}

startswith 判斷字串是不是某某開頭

endswith 判斷字串是不是某某結尾

count(a)

find("aa") 查詢"aa"出現的位置,如果沒有返回-1

isalnum 判斷是否有字母和數字組成

isalpha 判斷是否由字母組成

isdigit 判斷是否有數字組成

isnumeric 判斷數字(中文)

len() 內建函式.直接使用.不用點操作.判斷字串的長度

for 變數 in 可迭代物件 迴圈遍歷

元組不可變,只讀 ("a",) tuple 元組中的元素之時不允許刪除但是我們可以刪除整個元祖

• 元祖的不可變的意思是子元素是不可變,而子元素內部的子元素是可以變,這取決於子元素是否是可變物件

range(開始,結束,步長) 數字

insert 索引新增

• lst.insert(1,"劉德華")

extend 迭代新增(用新列表擴充套件原來的列表)

• lst.extend(["馬化騰","小澤"])

字典 dict

字典的key必須是可雜湊的,不可變,value沒有限制

不是按照我們儲存的順序儲存的,無序的

增

• setdefault() 如果字典中已經包含了這個key,不在繼續儲存
• 如果key重複了,會替換原來的value
• dict.update(dict2)
  • 把字典引數dict2的key/value對更新到字典dict裡,如果鍵值有重複,更新替換

刪除

• pop() 刪除一個元素返回value
• popitem() 隨機刪除
• clear() 清空

查詢

• div[key] 如果key不存在就會報錯
• get("aa","bb") 可以通過key來獲取value的值,如果key不存在,返回None,可以給出一個預設值,當key不存在的時候返回預設值

keys 返回所有的key,雖然不是列表,但是可以迭代迴圈

values 返回所有的value

items 拿到所有的鍵值對

enumerate 列舉

is

比較記憶體地址是否相等

小資料池:字串 數字

字串

• 不能有特殊字元
• s * 20還是同一個地址,s * 21以後就是兩個地址

數字的範圍: -5-- 256

編碼

各個編碼之間的二進位制,是不能相互識別的,會產生亂碼

檔案的儲存,傳輸,不能是unicode(只能是utf-8 utf-16 gbk )

str 在記憶體中是用unicode編碼

bytes 型別

s=b'alex'

encode 編碼,如何將str-> bytes

decode 解碼

fromkeys

• dic.fromkeys(keys,value) 返回的是一個字典 ,將keys的所有元素分別列印,對應的是value

join() 把列表變成字串

列表不能再迴圈的時候刪除,因為索引會跟著改變

# # 氣泡排序
# # lst=[86,3,5,7,23,53,13]
# # for i in range(len(lst)): # 記錄內部排序的次數
# #     i=0
# #     while i<len(lst)-1:
# #         if lst[i]>lst[i+1]:
# #             lst[i],lst[i+1]=lst[i+1],lst[i]
# #         i=i+1

檔案操作

r,rb只讀(位元組b)

w,wb 只寫

a,ab 追加

r+ 讀寫

在r+模式下,如果讀寫了內容,不論讀取內容多少,游標顯示的是多少,在寫入或者操作檔案的時候都是在結尾進行的操作

read

w+ 寫讀

a+ 寫讀(追加寫讀)

seek(n) 游標移動的位置

• seek(0) 開頭
• seek(0,) 第二個引數 0:在開頭,1:在當前,2:末尾

write 在沒有任何操作之前進行寫,在開頭寫,如果讀取過後就在末尾寫

tell()

移動到當前位置

檔案修改

• 建立新檔案,把修改後的內容寫入新檔案,刪除老檔案,重新命名新檔案

• rename 改名字

• import os

flush() 重新整理緩衝區

def 函式名

三元運算子

a if a>b else b

*food 可以傳入任意的位置引數,動態引數必須在位置引數後面,收到的內容是元組tuple

** 來接收動態關鍵字引數

關鍵字引數必須在位置引數後面,否則引數會混亂

順序:

位置引數>*args>預設值引數>**kwargs

globals 全域性作用域

不再使用區域性作用域中的內容而改成全域性作用域中的變數

nonlocal表示在區域性作用中,呼叫父級使用空間中的變數(父級使用內部變數)

locals() 區域性作用域

sum() 求和

def extendList(val,list=[]):
    list.append(val)
    return list
list1=extendList(10)
print("list1=%s"% list1)
# list=[10]
list2=extendList(123,[])
print("list=%s" % list2)
# list=[123]
list3=extendList("a")
print("list3=%s"% list3)
# list=[10,"a"]
key沒有改變所有指向同一個物件

閉包

閉包就是內層函式,對外層函式(非全部)的變數的引用

_closure_ 檢測函式是否是閉包,使用函式名._closure_ 返回cell就是閉包,返回None就不是閉包

__iter__() 獲取迭代器 __next__() 迭代物件

yield 返回結果 可以讓函式分段執行

send(值) 讓生成器向下執行一次,給上一個yield傳一個值(第一個和最後一個是不用傳的)

列表推導式

[最終的結果(變數) for 變數 in 可迭代物件 if 篩選的條件]

lst=[ i for i in range(1,15)]

生成器表示式

g=(i for i in range(10))
print(list(g))
不同點,一個是[] 一個是(),一個是一次性給你好記憶體,一個是一個一個給你
得到的值不一樣,列表推導式得到的值一個生成器
生成器要值的時候才去取

字典推導式

dic={lst[i]:lst2[i] for i in range(len(lst))}

集合推導式

lst=["那化騰","馬化騰","王建中","張建忠","張雪峰","張雪峰","張雪峰"]
s={i for i in lst}
print(s)
去重

沒有元組推到式,不過可以認為是生成器表示式

字典是key:value 集合是key

　內建函式

iter() 迭代

next() 輸出下一個

print("aa","bb","cc") sep:分隔符 end最後

hash演算法 目的是唯一,列表是不可雜湊的,元組可以

callable() 是否是可以呼叫的

字串的執行

• eval 執行簡單的運算
• exec 執行字串函式

divmod 求商和餘數

round 五舍六入

pow(a,b) a的b次冪

sum() 求和

max() 最大值

min() 最小值

reversed 倒序 list()

slice()

s=slice(1,3,1)
print(lst[s])

repr 原樣輸出,過濾掉轉義字元\n\t\r不管百分號

ord 返回編碼表中的碼位

chr 已知碼位計算字元

format

enumerate() 把索引和元素一起獲取,索引預設從0開始

lst=["A","B","c","d"]
for index,el in enumerate(lst,100):
    print(index)
    print(el)

all() 全部是True返回True(可迭代物件)

any() 有一個是True則是True(可迭代物件)

lembda() 匿名函式

a=lambda x:x*x    語法:lambda 引數:返回值

__name__ 檢視函式名

sorted 要給一個物件接受,reverseed 引數為True False 升序降序

lst=[
    {"id":1,"name":"alex","age":18},
    {"id":2,"name":"taibai","age":19},
    {"id":3,"name":"wusir","age":13},
    {"id":4,"name":"ritian","age":11},
    {"id":5,"name":"nvshen","age":12},
]
def func(dic):
    return dic["age"]
l1=sorted(lst,key=func)
print(l1)

filter 第一個引數是函式,第二個引數是可迭代的物件

lst=[1,3,4,5,6,7,8]
li=filter(lambda i:i%2==1,lst)
print(list(li))
list(filter(lambda dic:dic["age"]>40,lst))

map

lst=[1,2,3,4,5,6,7]
def func(i):
    return i*i
li=map(func,lst)
print(list(li))

lst1=[1,3,5,6,7,8]
lst2=[2,43,4,5,6,8]
print(list(map(lambda x,y:x+y, lst1,lst2)))
#如果傳入的多個引數,後面的列表要一一對應

遞迴

　面向物件

Person.__dict__ 查詢類中的所有內容(不能進行增刪改操作)

函式.屬性 對類中的單個的變數進行增刪改查

1. 類名+()產生一個例項(物件,物件空間)

2. 自動執行類中的__init__ ,將物件空間傳給__init__ 的self 引數

3. 給物件封裝相應的屬性

4. Person.money="貨幣" # 增
   Person.animal="中等動物" # 改
   del Person.mind #刪除
   print(Person.__dict__)

class Count:
    count = 0

    def __init__(self):
        Count.count = self.count + 1
   檢視類被呼叫幾次

通過類名可以更改我的類中的靜態變數值

Count.count=6
Count.__dict__
但是通過物件,不能改變只能引用類中的靜態變數

類的兩個屬性

靜態屬性就是直接在類中定義的變數

動態屬性就是定義在類中的方法

組合(不太懂)

from math import pi
# 求圓和圓環的面積和周長
class Circle:
    def __init__(self,r):
        self.r=r

    def aera(self):
        return self.r**2*pi
    def perimeter(self):
        return self.r*2*pi

class Ring:
    def __init__(self,r1,r2):
        self.r1=Circle(r1)
        self.r2=Circle(r2)

    def area(self):
        return self.r1.aera()-self.r2.aera()
    def perimeter(self):
        return self.r1.perimeter()+self.r2.perimeter()

繼承

只執行父類的方法:子類中不要定義與父類同名的方法

自執行子類的方法:在子類建立這個方法

既要執行子類的方法,又要執行父類的方法:

super().__init__(name,sex,age)

繼承:單繼承,多繼承

類:經典類,新式類

新式類:凡是繼承object都是新式類

python3x 所有的類都是新式類,因為python3x中的類預設繼承object

經典類:不繼承object都是經典類

python2x 所有的類預設都不繼承object,所有類預設都是經典類,你可以讓其繼承新式類

單繼承:新式類,經典類的查詢順序一樣

多繼承:

• 新式類:遵循廣度優先 類名.mro()
• 經典類:遵循深度優先
• 多繼承的新式類 廣度優先:一條路走到倒數第二級,判斷,如果其他路能走到終點,則返回走別一條路,如果不能,則走到終點
• 多繼承的經典類:一條路走到黑
• 深度優先,廣度優先:只能是繼承兩個類的情況

繼承的優點:

• 節約程式碼
• 規範程式碼

統一化介面設計

• # class Alipay:
  #     def __init__(self, money):
  #         self.money = money
  #
  #     def pay(self):
  #         print("使用京東支付了%s" % self.money)
  #
  #
  # class Jdpay:
  #     def __init__(self, money):
  #         self.money = money
  #
  #     def pay(self):
  #         print("使用京東支付了%s" % self.money)
  def pay(obj):
      obj.pay()
  
  a1 = Alipay(200)
  j1 = Jdpay(100)
  pay(a1)

抽象類介面類

from abc import ABCMEta, abstractmethod


class Payment(metaclass=ABCMEta):# 抽象類(介面類)
    @abstractmethod# 強制指定一個規範,凡事繼承我的類中必須有pay方法,如果,如果沒有就會報錯
    def pay(self):
        pass

封裝

廣義的封裝: 把方法和屬性都封裝在一個類裡,定義一個規範來描述一類事物

狹義的封裝: 私有化,只有在類的內部訪問

__age 對於私有靜態欄位來說,只能在本類中,類的外部

python處處都是多型

• 一種型別的多種形態,多個子類去繼承父類,那麼每一個子類都是這個父類的一種形態

property 裝飾器函式,內建函式,幫助你將類中的方法偽裝成屬性,特性

• 呼叫方法的時候不需要主動加括號
• 讓程式的邏輯性更合理
• @方法名.setter 裝飾器,修改被property裝飾的屬性的時候會呼叫被這個
• @方法名.deleter 裝飾器,修改被property裝飾的屬性的時候會呼叫被這個裝飾器裝飾的方法,除了self之外還有一個引數,被修改的值

靜態方法

class A:
    @staticmethod
    def func():
        print(666)
A.func()

類方法

# class A:
#     name="alex"
#     count=1
#     @classmethod
#     def func(cls): # 此方法無需物件參與
#         print(cls)
#         print(cls.age)
#     def func2(self):
#         print(self)
# class B(A):
#     age=22
#     def f1(self):
#         pass
# # B.func()
# b1=B()
# b1.func2()

屬性:將方法偽裝成一個屬性,程式碼上沒有什麼提升,只是更合理
@property
@屬性名.setter
@屬性.deleter
類方法
@classmethod
只能有類名呼叫(物件呼叫,傳給cls引數也是該物件的所屬類)
使用場景
1.無序物件參與
2.對類中的靜態變數進行修改
3.在父類中類方法得到子類的類空間
靜態方法
@staticmethod
程式碼性,清晰
複用性

isinstance() 判斷物件所屬型別,包括繼承關係

issubclass() 判斷類與類之間的繼承關係(前面父類,後面子類)

class A:pass
class B(A):pass
print(issubclass(B,A))# True
print(issubclass(A,B))#False

反射

反射: 用字串資料型別的變數名來訪問這個變數的值

class Student:
    ROLE = 'STUDENT'
# eval 這個東西 明確的寫在你的程式碼裡
print(Student.ROLE)
# 'ROLE'
# eval()
print(getattr(Student,"ROLE"))

反射的方法:getatter hasattr setattr delattr

class Student:
    ROLE = 'STUDENT'

    @classmethod
    def check_course(cls):
        print('檢視課程了')

    @staticmethod
    def login():
        print("登入")

# 反射檢視屬性
print(Student.ROLE)
print(getattr(Student, "ROLE"))
print(Student.__dict__)
# 反射呼叫方法
# getattr(Student,'check_course')() #類方法
# getattr(Student,'login')() # 靜態方法
num = input(">>>")
if hasattr(Student, num):
    getattr(Student, num)()

setattr(a,'name','alex_SB') 物件,屬性,替換的屬性

單例(指向同一塊記憶體空間)

• 如果一個類,從頭到尾只有一個例項,說明從頭到尾只開闢一塊屬於物件的空間,那麼這個類就是一個單例類

__call__ 相當於物件()

Lisp語言???

a.func 就是在a物件中儲存了類物件的指標(想當於記錄了func地址的變數)

抽象類和介面類

classmethod 類方法的裝飾器, 內建函式

staticmethod 靜態方法的裝飾器 內建函式

如果一個類裡面的方法,既不需要用到self中的資源,也不用cls中的資源,想當於一個普通的函式

但是你由於某種原因,還要拿這個方法放在類中,這個時候,就將這個方法變成一個靜態方法

某種原因:

• 你完全想用面向物件程式設計,所有的函式都必須寫在類中
• 某個功能確確實實施這個類的方法,但是確確實實沒有用過和這個類有關係的資源

列表中不要用pop(引數) insert() 特別消耗效能,但是可以用pop() append()

import sys
mymodule=sys.modules["__mian__"]
getattr(mymodule,"變數名")

__名字__ 不是被直接呼叫

間接呼叫: 內建函式/面向物件中特殊語法/python提供的語法糖

__str__ :str(obj) 要求必須實現__str__ 要求這個方法的返回值必須是字串str型別

__call__ : 物件() 用類寫裝飾器

__len__ : 要求obj必須實現了__len__,要求這個方法的返回值必須是數字int型別

__new__: 在例項化的過程中,最先執行的方法,在執行init之前,用來創造一個物件,構造方法

__init__ : 在例項化的過程中,在new執行之後,自動觸發的一個初始化

__repr__ 是__str__ 的備胎,如果有__str__ 沒有的話要向上找,只要父類不是object,就執行父類的__str__ ,但是如果出了object之外的父類都沒有__str__方法,就執行子類的__repr__ 方法,如果子類也沒有,還要向上繼續找父類中的__repr__ 方法,一直到找不到,再執行object類中的__str__ 方法

hash

hash方法

底層資料結構基於hash值定址的優化操作

hash是一個演算法,能夠把某一個要存在記憶體裡的值通過一系列計算,保證不同值的hash結果是不一樣的

對同一個值在多次執行python程式碼的時候hash值不一樣

但是對同一個值,在同一次執行python程式碼的時候hash值永遠不變