python 入門總結(一)
自然語言用雙引號,機器語言用單引號 例如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()
刪除一個元素返回valuepopitem()
隨機刪除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__
查詢類中的所有內容(不能進行增刪改操作)
函式.屬性
對類中的單個的變數進行增刪改查
類名+()產生一個例項(物件,物件空間)
自動執行類中的
__init__
,將物件空間傳給__init__
的self 引數給物件封裝相應的屬性
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值永遠不變