python notes
一、python的定義
：Python 是一個高級動態、解釋性、編譯性、互動性和面向物件的腳本語言，
二 、python的特點：
1、簡單靈活
2、 開源免費
3、 跨平臺
4、 高級動態
5、 支持命令式編程
6、函式式編程
7、 面向物件編程
三、python的基本資料型別
標準資料型別：數字（Number）、字串（String）、串列（List）、元組（Tuple）、集合（Set）和字典（Dictionary）；
（1）：不可變資料：Number（數字）、String（字串）、Tuple（元組）；
（2）：可變資料：List（串列）、Dictionary（字典）、Set（集合），
1、數字型別：
```python
>>> a=10 #整型
>>> b=2.12 #浮點型
>>> c=True #bool型
>>> d=1+2j #complex（復數型）
>>> print(type(a)) #單個輸出
<class 'int'>
>>> print(type(a),type(b),type(c),type(d)) #全部輸出
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
>>>
2、運算子：
算數運算、比較運算、賦值運算、位運算、邏輯運算、成員運算、身份運算
（1）、算數運算子
+
加 - 兩個物件相加
```python
>>>a=10
>>> b=20
>>> a
10
>>> a+b
30
減 - 得到負數或是一個數減去另一個數
>>>a=10
>>> b=20
>>> a-b
-10
乘 - 兩個數相乘或是回傳一個被重復若干次的字串
>>>a=10
>>> b=20
>>> a*b
200
/
除 - x 除以 y
>>>a=10
>>> b=20
>>> a/b
0.5
%
取模 - 回傳除法的余數
>>>a=10
>>> b=20
>>> a%b
10
**
冪 - 回傳x的y次冪
>>>a=10
>>> b=20
>>> a**b
100000000000000000000
//
取整除 - 向下取接近商的整數
>>>a=10
>>> b=20
>>> a//b
0
（2）、比較運算子
★☆ 等于(==) : (a == b) 比較物件是否相等
★☆ 不等于(!=): (a != b) 比較兩個物件是否不相等
★☆ 大于(>): (a > b)
★☆ 小于(<)：所有比較運算子回傳1表示真，回傳0表示假，與變數True和False等價，
★☆ 大于等于 (>=): (a >= b)
★☆ 小于等于(<=) : (a<=b)，
（3）、賦值運算子(=)
★☆簡單的賦值運算子(=)
c = a + b
★☆ 加法賦值運算子(+=)
c += a 和 c = c + a表示的相同，只是不同的寫法，
★☆ 減法賦值運算子（-=）
c -= a 和 c = c - a表示的相同，只是不同的寫法，
★☆ 乘法賦值運算子（*=）
c *= a 和 c = c * a表示的相同，只是不同的寫法，
★☆ 除法賦值運算子（/=）
c /= a 和c = c / a表示的相同，只是不同的寫法，
★☆ 取模賦值運算子（%=）
c % = a和 c = c % a表示的相同，只是不同的寫法，
★☆ 冪賦值運算子（**=）
c **= a 和c = c ** a表示的相同，只是不同的寫法，
★☆ 取整除賦值運算子（//=）
c //= a 和 c = c // a表示的相同，只是不同的寫法，
★☆ 海象運算子（:=）：可在內部給變數賦值，
（4）、位運算子（ &）
☆按位與運算子：
參與運算的兩個值,如果兩個相應位都為1,則該位的結果為1,否則為0
☆& ：
>>> a,b=12,34
>>> print(a&b)
0
☆|：
按位或運算子：只要對應的二個二進位有一個為1時，結果位就為1，
>>> a,b=12,34
>>> print(a|b)
46
☆^:
按位異或運算子：當兩對應的二進位相異時，結果為1
>>> a,b=12,34
>>> print(a^b)
46
☆~:
按位取反運算子：對資料的每個二進制位取反,即把1變為0,把0變為1，~x 相當于 -x-1
>>> a,b=12,34
>>> print(~a)
-13
左移動運算子（<<）："<<"右邊的數指定移動的位數，高位丟棄，低位補0，
>>> a,b=12,34
>>> a<<2
48
☆>>:右邊的數指定移動的位數
>>> a,b=12,34
>>> a>>2
3
（5）、邏輯運算子
☆ and：
>>> a,b=10,20
>>> print(a and b)
20
☆or：
>>> a,b=10,20
>>> print(a or b)
10
☆not：
>>> a,b=10,20
>>> print(not a)
False
>>> a,b=10,20
>>> print(not a and b)
False
（6）、成員運算子
?in：
在指定的序列中找到值，回傳 True，否則回傳 False，
x 在 y 序列中為True，
?not in：
在指定的序列中沒有找到值回傳 True，否則回傳 False，
x 不在 y 序列種為 True，
（7）、身份運算子
?is：is 是判斷兩個識別符號是不是參考一個物件
x is y,參考的同一個物件為True，反之為False
?is not：is not 是判斷兩個識別符號是不是參考不同物件
x is not y ，參考的不是同一個物件為 True，反之為 False，
2、字串
字串的常用方法：索引、拼接、重復、切片…
★字串中的索引
格式：變數[起始下標：終止下標]
索引的值是從零開始的，-1為尾，
★ 字串的切片
格式：[起始值：結束值：步長值]：
```python
>>> a='qwerty'
>>> print(a[0]) #取第一個值，字串的起始位置的下標為0
q
>>> print(a[-1])#取最后一個值
y
>>> print(a[1:3])#取下標為1到3的值
we
```>>> print(a[2:])#取下標為2到尾部的值`
erty
>>> print(a[:3])#取下標初始位置的到下標結束的值（切片）
qwe
>>> print(a[0:5]+'hello')#字串的拼接用加號+
qwerthello
>>> print(a*2)#重復
qwertyqwerty
3、轉義字符
★ (在行尾時)\續行符
★ \反斜杠符號
★ '單引號
★ "雙引號
★ \a響鈴
★ \b退格
★ \000空
★ \n換行
★ \v縱向制表符
★ \t橫向制表符
★ \r回車
★ \f換頁
★ \oyy八進制數，yy 代表的字符，例如：\o12 代表換行，其中 o 是字母，不是數字 0，
★ \xyy十六進制數，yy代表的字符，例如：\x0a代表換行
★ \other其它的字符以普通格式輸出
例子：
>>> sad="a:\"let\'s together study python!\"\nsadq:'nice'"
>>> print(sad)
a:"let's together study python!"
sadq:'nice'
>>>
★字串是由數字、字母、下劃線組成的一串字符，表示文本的資料型別
集合
只包含鍵的字典，元素不重復
set（）創建函式，其沒有引數則為空集
集合簡例：
>>> s1=set([1,2,3,4，4])#集合可去重
>>> print(s1)
{1, 2, 3, 4}
集合運算：
?交集：
>>> s1=set([1,2,3,4,4])
>>>> s2=set([2,3,4,5,6])
>>> print(s1 & s2) #交集結果取兩組資料中共有的數
{2, 3, 4}
?并集：
>>> s1=set([1,2,3,4,4])
>>> s2=set([2,3,4,5,6])
>>> print(s1 | s2)#并集結果取兩組資料中所有的數
{1, 2, 3, 4, 5, 6}
?差集：
>>> s1=set([1,2,3,4,4])
>>> s2=set([2,3,4,5,6])
>>> print(s2-s1)
{5, 6}
>>>
?對稱差集：
>>> s1=set([1,2,3,4,4])
>>> s2=set([2,3,4,5,6])
>>> print(s1^s2)#相當于并集-交集
{1, 5, 6}
集合的常用方法：
★add（）添加元素
★remove（）和discard（）洗掉元素，兩者區別：如果要洗掉的元素不存在，remove（）會報錯，discard（）不報錯，
★pop（）隨機洗掉，內部自動排序
★clear（）清空集合
串列
?串列的語法：[運算式 for 變數 in 串列]
[運算式 for 變數 in 串列 if 條件]
?運算式：串列生成元素運算式，可以是有回傳值的函式，
?for變數 in串列：迭代串列將元素傳入運算式中，如果有if則先交給if過濾，
?if條件根據條件過濾
?用法：
>>> lis=[1,2,3,4]
>>> [x**2 for x in lis]#求所有元素的平方
[1, 4, 9, 16]
>>> [x for x in lis if x%2==0]#篩選出偶數
[2, 4]
>>>#4和6的倍數
>>> [i for i in range(1,10)if i%4==0 or i%6==0]
[4, 6, 8]
>>> sum([i for i in range(1,10)if i%4==0 or i%6==0])
18
>>>
?del 陳述句來洗掉串列的的元素
>>> list = ['P', 'U', 16, 20]
>>> print(list)
['P', 'U', 16, 20]
>>> del list[3]
>>> print(list)
['P', 'U', 16]#串列中的下標為三且在其居第四個位置的元元素16已被洗掉
>>> print(len([1,2,3]))#長度
3
>>> print(['i','love']+['python'])#組合
['i', 'love', 'python']
>>> print(['python']*4)#重復
['python', 'python', 'python', 'python']
>>> print(5in [1,3,5,7])#元素是否在串列中，True則在
True
>>>
元組
? 元組的創建符號是（）
>>> y=(1,2,3,4,'a','b')
>>> u=('y','u','z','16')
>>> y,u
((1, 2, 3, 4, 'a', 'b'), ('y', 'u', 'z', '16'))
>>>
>>> z=16,
>>> type(z)
<class 'tuple'>
>>>
>>> null=()#空元組
>>> null
()
>>> print(len((1,2,3)))#元組的個數
3
>>> print((1,2,3,4)+(5,6))#連接
(1, 2, 3, 4, 5, 6)
>>> print(('good',)*6)#復習
('good', 'good', 'good', 'good', 'good', 'good')
>>> print(3 in (1, 2, 6))#元素是否存在
False#元素不存在則為False
>>>
? 元組的內置函式
?len(tuple)計算元組元素個數，
>>> tuple1 = ('G', 'U', 'IOOO')
>>> len(tuple1)
3
?max(tuple)回傳元組中元素最大值，
>>> tuple2 = ('1', '5', '10')
>>> max(tuple2)
'10'
?min(tuple)回傳元組中元素最小值，
>>> tuple2 = ('0', '6', '8')
>>> min(tuple2)
'0'
?tuple(iterable)將可迭代系列轉換為元組，
>>> list=['A','B','C','D']
>>> tuple=tuple(list)
>>> tuple
('A', 'B', 'C', 'D')
>>>
字典
〇
字典的組成：鍵（key）和值（value）字典中的值沒有特殊的順序，鍵可以是數字、字串、元組，鍵只能是不可變資料型別
〇
格式：變數名={key：value}
>>> dict = {'Name': 'marry', 'Age': 20, 'Class': 'D3'}
>>> print ("dict['Name']: ", dict['Name'])
dict['Name']: marry
>>> print ("dict['Age']: ", dict['Age'])
dict['Age']: 20
>>>
>>> del dict['Age']#洗掉元素Age
>>> print(dict)
{'Name': 'marry', 'Class': 'D3'}
>>>
>>> dict.clear()#清空字典
>>> print(dict)
{}
>>> dict = {'Name': 'R', 'Age': 7, 'Class': 'F9'}
>>> dict['Age'] = 20 # 更新 Age
>>> dict['School'] = "www" # 添加資訊
>>> print ("dict['Age']: ", dict['Age'])
dict['Age']: 20
>>> print ("dict['School']: ", dict['School'])
dict['School']: www
>>>
字典的內置函式（方法）
☆len(dict)計算字典元素總數，
>>> dict = {'Name': 'A', 'Age': 9, 'Class': 'F8'}
>>> len(dict)
3
☆str(dict)輸出字典，列印，
>>> dict = {'Name': 'S', 'Age': 17, 'Class': '8'}
>>> str(dict)
"{'Name': 'S', 'Class': '8', 'Age': 17}"
☆type(variable)回傳輸入的變數型別，如果變數是字典就回傳字典型別，
>>> dict = {'Name': 'A', 'Age': 3, 'Class': '5'}
>>> type(dict)
<class 'dict'>
函式
🎈函式的定義：一個被封裝的具有特定功能的代碼段
🎈函式的特點：重復使用
🎈函式名：給封裝好的代碼段起別名
🎈形參：本質上一個區域變數，用于接收外部的資料，它是在定義函式時定義的
🎈實參：在函式呼叫執行時,傳遞的資料
回傳值：將函式中的區域變數傳遞到外部，return為關鍵字，回傳一個值，注意：return陳述句一旦執行函式就會終止，其他陳述句都不會執行，yield可以讓函式多次回傳多個值
>>> def a(x):
if x<0:
return-x
else:
return x
print(x)#無效
🎈變數作用域：（起作用的范圍）就是定義在變數可以使用的代碼范圍
🎈全域變數：在整個函式中都可以被呼叫的變數，一般直接定義在函式的外部或者用global關鍵字在函式內部定義，（是可以被所有的函式訪問的，除非被刪掉否則一直存活到腳本運行結束，）
>>> l='hello'
>>> def f():
global l
l='hello '#全域變數l
print(l)
>>> print(l)
hello
🎈區域變數：（只在函式內部有用）
函式內部定義的變數包括形參，只能在函式內部被呼叫，函式內部優先使用區域變數（速度快）
🎈注意：在函式中使用全域變數時可以呼叫全部變數的值，不能直接修改全域變數的值（值如果是可變型別，值是可以改變 ）
引數的型別
〇位置引數：實參的賦值時和形參定義的順序一致
>>> def t1(x,y,z):
print(x,y,z)
>>> t1(1,2,3)
1 2 3
〇命名引數：可以不按順序賦值
>>> t1(z=1,x=2,y=3)
2 3 1
〇默認值引數：定義形參時給形參默認值，默認值引數寫在引數串列的最右側
>>> def t2(x=1,y=2,z=3):
print(x,y,z)
>>> t2()#默認值
1 2 3
>>> t2(3,2,1)
3 2 1
>>> t2(y=100)
1 100 3
>>>
〇可變長度引數：在普通引數前加*，將任意長度的東西存在元組中
>>> def t3(*args):
print(args)
>>> t3(1,2,3,4,5)
(1, 2, 3, 4, 5)
>>>
>>> def my_a(*args):
m=args[0]
for i in args[1:]:
if m<i:
m=i
return m
>>> print(my_a(3,4,8,900,6,100,29))
4
〇可變長度的命名引數：作用為接收命名引數，在普通形參前加**
def l(**k):
print(k)
l(name="root",password="123456",port=3306)
def l(**k):
for i in k:
print(i,"->",k[i])
data={'host':'ll','username':'olo','password':'11122334'}
l(**data)
匿名函式
? 格式：lambda[形參]:回傳值
print((lambda x:x**2)(8))#第一個x表示形參，第二個x表示回傳值
64
>>> f=lambda name:print("hello%s" % (name))
>>> f("ameery")
helloameery
? 三目運算：
值1 if條件 else 值2 條件為真結果值為值1，結果為假結果為值2
>>> f1=lambda age:"你已經成年"if age>18 else "你還沒有成年"
>>> print(f1(19))
你已經成年
>>> print(f1(17))
你還沒有成年
>>>
高階函式:
?定義：將函式作為引數或回傳值的函式，
?高階函式的特點：函式可以作為引數被傳遞，可以作為回傳值輸出
>>> def a_add(f,x,y):
return f(x)+f(y)
>>> print(a_add(lambda a:a**2,3,4))#將函式作為引數
25#相當于2的平方加3的平方加4的平方
?函式柯里化:是把接受多個引數的函式變成接受一個單一引數（最初函式的第一個引數）的函式，并且回傳接受余下的引數且回傳結果的新函式的技術，
>>> def func1(x):
def func2(y):
return x+y
return func2
>>> f3=func1(3)
>>> print(f3(4))
7
?高階函式五個常用的函式（map、reduce、filter、sorted、resersed）
（1）map函式
- map（）函式接收兩個引數，一個是函式一個是序列
- map的作用：將傳入的函式依次作用到序列的每一個元素，并把結果作為新的序列物件回傳，
- 例如：一個函式f（x）=x2，把這個函式作用在一個list[1,2,3,4,5,6,7,8,9]上，就可以用map（）實作：
?map（）代碼例子：
#map(f,lis)至少需要一個形參
>>> def dunc(x):
return x**3
>>> items=map(dunc,range(10))
>>> print(list (items))
[0, 1, 8, 27, 64, 125, 216, 343, 512, 729]
>>>
（2）reduce（）函式
累加函式需引入模塊
作用：前兩個值結果和后一個值結果運算
>>> from functools import reduce#引入模塊
>>> def add(x,y):
return x+y
>>> res=reduce(add,range(5))
>>> print(res)
10 #結果程序是0+1→1+2→3+3→6+4=10
>>>
（3）filter（）內置函式
- filter（）函式用于過濾序列
- 與map（）類似，filter（）也接收一個函式和一個序列，不同的是filter（）把傳入的函式依次用作于每個元素，
- 作用：函式回傳值為真則保留，為假則舍掉，
>>> r1=filter(None,[0,1,"","a",[],{},(),True,False])
>>> print(r1)
<filter object at 0x0000019C92CFAEE0>
>>> r1=filter(lambda x: True if x>5 else False,[0,1,2,3,4,5,6,7,8,9,] )
>>> print(list(r1))
[6, 7, 8, 9]
（4）sorted（）內置函式
- sorted（）函式也是一個高階函式，也稱之為排序函式
- 作用：接受收一個key函式來實作自定義的排序，（比如按照絕對值大小排序，按照字串長度排序）
>>> import random
>>> lis=[random.randint(1,100) for i in range(10)]
>>> print(sorted(lis))
[11, 20, 28, 35, 38, 51, 53, 60, 63, 90] #按照大小排序
閉包函式：
- 閉：函式里面還嵌套了函式
- 包：包含了對外部函式作用域中變數的參考
- .內部函式:包含對外部作用域而非全域作用域變數的參考，該內部函式成為閉包函式，
- 特點：內不含食宿參考了外部函式的變數
def outer(a): #outer是外部函式
b=10 #a,b都是函式外部的臨時變數
def inner(): #inner是內函式
print(a+b) #在內函式中用到了外部哈桑農戶的臨時變數
return inner #外函式的回傳值是內函式的參考
☆裝飾器函式：
裝飾器本質上也是一個函式，只不過這個函式接收其他函式作為引數并對其進行一定的改造之后回傳新函式，
函式
☆遞回函式：
☆定義：程式呼叫自身的編程技巧稱之為遞回（recursion）
☆注意:寫遞回函式一定要有結束條件，遞回有層次限制
☆例如：5的階乘
>>> def func(n):
if n==1 or n==0 :
return 1
else:
return n *func(n-1)
>>> print(func(5))
120 #結果的運算順序： 5！
5*4！
5*4*3！
5*4*3*2!
5*4*3*2*1!
☆正確輸出第n個數字的斐波那契數
>>> def fun(n):
if n<0:
print('輸入有誤')
elif n==1 or n==2:
return 1
else:
return fun(n-1)+fun(n-2)
>>> print(fun(6))
8
☆生成器函式：
- yield陳述句的函式可以用來創建成生成器物件
- 每一次執行到yield陳述句并回傳一個值之后會暫停或者掛起后面代碼的執行
- 生成器函式用于處理海量資料
- 作用;節省記憶體空間（減小記憶體空間壓力）
- 獲取生成器物件的值得兩種方法：
- （1）使用next（）–———一個個獲取資料
- (2)使用回圈for i in 變數 print（i） 一次性獲取完畢i
-只有使用next（）函式執行生成器物件或者回圈生成器物件時才會一個個回傳資料，
def func(c):
yield "a"
yield "b"
yield "c"
g=func(c)#執行生成器哈桑農戶時回傳生成器物件
>>> print(next(g))#單次輸出，只輸出一個a，再次運行輸出b...
>>>for i in g: #多次輸出a,b,c
print(i)
☆串列推導式：
>>> lis=[i for i in range(10) if i%2==0]
>>> print(lis)
[0, 2, 4, 6, 8]
☆元組生成器：
>>> l=[('a',['1','2'])]
>>> q_l=tuple(i for i in l)
>>> print(q_l)
(('a', ['1', '2']),)
☆利用生成器函式寫出斐波那契數列（兔子數列）
斐波那契數列特點：后一個值是前兩個數之和，例如：01，1，2，3，5，8，13，21，，，（0+1=1，1+1=2，2+1=3…）
>>> def fib(n):
a,b=0,1
while a<n:
yield a #暫停執行，需要時再產生一個顯得元素
a,b=b,a+b #繼續生成新元素
>>>
>>> for i in fib(10):
print(i)
0
1
1
2
3
5
8
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/198746.html
標籤：其他