Python 學習筆記（最全知識點）

所用編譯器VScode

所用學習網站 https://www.liaoxuefeng.com/wiki/1016959663602400

一：輸入和輸出

n=input()#定義一個變量並輸入這個變量
print(n)#自帶回車

m=input('please enter your name:')
print(m)


print('aaaa')
print("aaaa")

# 一行輸入多個整數 ， 存入列表中並輸出
lis = []
lis = list(map(int, input().split()))
for i in range(len(lis)):
    print (lis[i])


#多組輸入，讀到文件尾
while True:
    try:
        a,b=map(int,input().split())#一行輸入多個數
        print(a+b)
    except:
        break

二：list 

#定義一個數組
n =[2,3,4,5]
#輸出數組中元素的個數
print(len(n))

print(n[3])
#輸出5，下標從0開始

#如果要取最後一個元素，除了計算索引位置外，還可以用-1做索引，直接獲取最後一個元素：
print(n[-1])
#同理最後第二個元素-2……只要不越界


#追加元素到末尾
n.append(8)
#插入到指定位置
n.insert(1,6)
#刪除末尾的元素
n.pop()
#刪除指定位置的元素，默認最後一個，並返回位置
n.pop(1)

n.remove(1)
#用於刪除列表中第一個與指定值相等的元素，該值必須存在

#將某個元素換成別的元素
n[1]=9

#刪除元素（位置）
del n[3]


#數組元素類型也可以不相同
s=['AAA',123,true]

#可以list套list,相當於二維數組
p=['123','456',['789','aaa']]

a=['c','b','a']
a.sort()
print(a)
#list是可變對象，輸出['a','b','c']

#sort()是Python列表的一個內置的排序算法，list.sort()方法排序時直接修改原列表，返回None
#sorted()是Python內置的一個排序函數，它會從一個迭代器返回一個排好序的新列表

#定義一個串是不可變對象
a='abc'
print(a.replace('a','A'))#輸出Abc
print(a)#輸出abc

#列表推導式


x = [i*i for i in range(10)]
print(x)
#輸出[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

xx = [-1,-4,6,7.5,-2.3,9,-11]
y = [i for i in xx if i>0]
print(y)
#輸出[6, 7.5, 9]

三：條件判斷 

#根據Python的縮進規則，如果if語句判斷是True，就把縮進的兩行print語句執行了，否則，什麼也不做。
n=8
if n>=8:
    print("yes")
    print("YES")
else:
    print("NO")
    print("no")

 四：循環

（1）for循環 

n=[1,2,3,4]
for n in n:
    print(n)
#輸出每個元素

#計算1到10的和
sum=0
for x in [1,2,3,4,5,6,7,8,9,10]:
    sum=sum+x
print(sum)

#那要是計算1到100呢
#Python提供了一個函數range()，可以生成一個整數序列，再通過list()函數可以轉換爲list。
#range(start,end,step)step默認爲1，經常不寫
#eg:  list(range(10,1,-3))  [10,7,4]
#range(101)生成0到100的序列
#range(1,101)生成1到100的序列


sum2=0
for x in list(range(101)):
    sum2+=x
print(sum2)




#編程計算1-2!+3!-4!+5!...前n項的值。
n=input()
n=int(n)#先轉換成int型
sum=0
p=1
for i in range(1,n+1):
    p*=i
    if i%2==0 :
        sum-=p
    else:
        sum+=p
print(sum)

（2）while循環

#計算1到100的和
sum=0
n=100
while n>0:
    sum=sum+n
    n=n-1
print(sum)

#可以使用break跳出循環，continue提前結束本輪循環，並直接開始下一輪循環

#“死循環”可以用Ctrl+C退出程序

五：使用dict和set

dict全稱dictionary，在其他語言中也稱爲map，使用鍵-值（key-value）存儲，具有極快的查找速度。

（1）dict（空間來換取時間）

d={'A':2,'B':5,'V':7}
print(d['V'])#輸出7
#'p'不存在可以在後面放入值，如果已經存在就替換,
d['P']=8
print(d['P'])
x=dict()#創建一個空的字典

#要避免key不存在的錯誤，有兩種辦法in 或者get
print('B' in d)#輸出True
print(d.get('C'))#輸出None
print(d.get('C',-1))#自定義不存在輸出-1，存在輸出鍵值

#刪除一個
d.pop('A')
print(d)#輸出{'B': 5, 'V': 7, 'P': 8}

 

#設計一個字典，用戶輸入一個‘鍵’，存在則輸出值，不存在則輸出-1
x={'xjh':99,'zcy':98}
name=input('請輸入你的姓名：')
if x.get(name,-1) == -1:
    print('該姓名不存在')
else:
    print(x[name])

#編寫程序，生成包含1000個0~100之間的隨機整數，統計並輸出每個整數出現的次數
import random
x={}
for i in range(1000):
    y=random.randint(0,100)
    y=int(y)
    if x.get(y,-1) == -1:
        x[y] = 1
    else:
        x[y] = x[y] + 1

for k,v in x.items():
    print(k,v)

 

 （2）set    set和dict類似，也是一組key的集合，但不存儲value。由於key不能重複，所以，在set中，沒有重複的key。

s=set([1,2,3])
print(s)
ss=set([1,1,2,2,2,3])
print(ss)
#s和ss存儲的元素個數是一樣的，都是輸出{1, 2, 3}
x=set()#創建一個空集合
s.pop()#刪除一個隨機的元素，並返回這個元素
s.add(5)#增加元素
s.remove(3)#刪除元素

#兩個set可以做數學意義上的交集、並集等操作
p=set([1,2,3])
pp=set([2,3,4])
print(p&pp)#輸出{2,3}
print(p|pp)#輸出{1,2,3,4}

五：函數

1.調用函數

#調用abs函數
print(abs(12.34))
print(abs(2))
#函數max()可以接收任意多個參數，並返回最大的那個
print(max(1,2))
print(max(1,2,3,4,5))
#用來數據類型轉換的函數
print(int('123')) #123
print(int(12.34)) #12
print(float('12.34')) #12.34
print(str(1.23)) #'1.23
print(bool('')) #False

a=abs # 變量a指向abs函數
print(a(-1))  # 所以也可以通過a調用abs函數

#求和函數
r = [1, 2, 3, 4, 5, 6]
print(sum(r))

2.定義函數（在Python中，定義一個函數要使用def語句，依次寫出函數名、括號、括號中的參數和冒號:，然後，在縮進塊中編寫函數體，函數的返回值用return語句返回。）

#eg:定義一個絕對值的函數
def my_abs(x):
    if x>=0:
        return x
    else:
        return -x

print(my_abs(-2))



#可以返回多個值
import math

def move(x,y):
    x=x+1
    y=y-1
    return x,y

print(move(1,2))

3.函數的參數

def power(x,n=2):#默認參數在後
    s = 1
    while n>0:
        n=n-1
        s=s*x
    return s
print(power(5))
print(power(5,2))

#計算a*a+b*b+……
def calc(numbers):
    sum = 0
    for n in numbers:
        sum =sum +n*n
    return sum
print(calc(([1,2,3])))   #14
print(calc([1,3,5,7]))   #84

#可以變爲可變參數，調用簡單一點,一個*接受多個位置參數並將其放在一個元組中
def calc1(*numbers):
    sum = 0
    for n in numbers:
        sum =sum +n*n
    return sum
print(calc1(1,2,3))   #14
print(calc1(1,3,5,7))   #84

nums =[1,2,3]
#對於已經存在的數組，有以下兩種調用方式
print(calc1(nums[0],nums[1],nums[2]))
print(calc1(*nums))

#**接受多個關鍵位置參數並存放到字典中
def demo(**p):
    for item in p.items():
        print(item)
print(demo(x=1,y=2,z=3))

#輸出
#('y', 2)
#('x', 1)
#('z', 3)
#關鍵字參數
def person(name,age,**kw):
    print('name:',name,'age:',age,'other:',kw)
person('Bob',35,city='Beijing',job='student')
#輸出name: Bob age: 35 other: {'city': 'Beijing', 'job': 'student'}

4.遞歸函數

#計算n!
def fact(n):
    if n==1:
        return 1
    return n*fact(n-1)
print(fact(3))

5.變量作用域

#全局變量可以用關鍵字global來定義
#（1）一個變量已在函數外定義，如果函數內需要爲這個變量賦值，並要將這個賦值結果反映到函數外，
#可以在函#數內使用global將其聲明爲全局變量
#（2）如果一個變量在函數外沒有定義，在函數內部也可以直接將一個變量定義爲全局變量，該函數執行後，將增#加一個新的全局變量。
#注意：在某個作用域內任意位置只要有爲變量賦值的操作，該變量在這個作用域內就是局部變量，除非使用#global進行了聲明。
#eg:
x = 3
def f():
    print(x)#本意是輸出x的值，但是不允許這樣做
    x = 5
    print(x)

f()

6.lambda表達式

#lambda用來聲明匿名函數，或者定義具名函數
#lambda表達式只可以包含一個表達式，該表達式的計算結果可以看做是函數的返回值，
#不允許包含複合語句，但在表達式中可以調用其它函數。
f = lambda x, y, z: x + y + z #可以給lambda表達式起名字
print(f(1, 2, 3))  #像函數一樣調用，輸出6
g = lambda x, y=2, z=3: x + y + z #參數默認值
print(g(1))#輸出6
print(g(2,z=4,y=5))#輸出11


print(123)
L = [1, 2, 3, 4, 5]
print(list(map(lambda x:x+10,L)))#模擬向量運算
#輸出[11,12,13,14,15],L的值並未變。

 

 

六：高級特性

1.切片

#[start:end:step]
#step默認爲1，可以不寫可以爲正，也可以爲負


L = ['Michael','Sarach','Tracy','Bob','Jack']
#取前3個元素
#方法1：
print( [ L[0],L[1],L[2] ] )

#方法2：
r = []
n=3
for i in range(n):
    r.append(L[i])
print(r)

#方法3:切片
print( L[0:3] ) #如果第一個索引是0，還可以省略：print( L[:3] )
print( L[1:3] ) #從1開始取2個元素
print( L[1:]) #從1開始取到末尾
#類似的，既然Python支持L[-1]取倒數第一個元素，那麼它同樣支持倒數切片，試試：
print( L[-2:] )#輸出['Bob', 'Jack']
print( L[-2:-1] )#輸出['Bob']


#在舉一個切片的例子，加深理解
R = list(range(100)) #創建一個0-99的數列
print( R[:10] ) #取前10個數
print( R[-10:] ) #取後10個數
print( R[10:20] ) #取11-20個數
print( R[:10:2] ) #前10個數，每兩個取1個
print( R[::5] ) #所有數，每5個取1個
print( R[:] ) #可以複製一個list
#同樣字符串'XXX'也可以看成一種list
print( 'ABCDEFG'[:3])

alist=[3,5,7]
alist[len(alist):]=[9]#在列表尾部增加元素
alist[:0]=[1,2]#在列表頭部插入
alist[3:3]#在列表中間位置插入
alist[:3]=[]#刪除前三個元素
alist[:3]=[1,2,3]#替換列表元素

2.迭代

d = {'a': 1, 'b': 2, 'c': 3}
#默認情況下，dict迭代的是key
for key in d:
    print(key)
#迭代value
for value in d.values():
    print(value)
#同時迭代key和value
for k, v in d.items():
    print(k, v)
#輸出
# ('a', 1)
# ('c', 3)
# ('b', 2)
for i, value in enumerate(['A', 'B', 'C']):
    print(i, value)
#輸出
#(0, 'A')
#(1, 'B')
#(2, 'C')

#引用兩個變量
for x, y in [(1, 1), (2, 3), (3, 6)]
    print(x, y)

3.列表生成式

#生成【1*1，2*2,3*3……】
#方法1
L = []
for x in range(1, 11):
    L.append(x * x)
print(L)
#方法2
print( [x*x for x in range(1,11)] )


#for循環後面還可以加上if判斷，這樣我們就可以篩選出僅偶數的平方：
print([x*x for x in range(1,11) if x%2==0])
#輸出[4, 16, 36, 64, 100]

#還可以使用兩層循環，可以生成全排列：
print( [x+y for x in 'ABC' for y in 'XYZ'] )
#輸出['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

#dict的items()可以同時迭代key和value
d = {'x': 'A', 'y': 'B', 'z': 'C'}
for k, v in d.items():
    print(k, '=', v)
#或
[k+'='+v for k,v in d.items()]

#把一個list中所有的字符串變成小寫：
L = ['Hello', 'Word', 'ABC']
print( [s.lower() for s in L] )

#使用內建的isinstance函數可以判斷一個變量是不是字符串：
x = 'abc'
y = 123
print(isinstance(x, str))#True
print(isinstance(y, str))#False
print(isinstance(y,int))#True

4.生成器

#創建一個generator
g = (x * x for x in range(10))

for n in g:
    print(n)

 

七：函數式編程

1.高階函數

#map()函數接收兩個參數，一個是函數，一個是Iterable
#eg:比如我們有一個函數f(x)=x2，要把這個函數作用在一個list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()實現如下
def f(x):
    return x * x
r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(r))

#把這個list所有數字轉爲字符串
r = map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(r))
#把這個list所有數字轉爲正數
r = map(abs, [-1, -2, -3, -4, -5, 6, 7, 8, 9])
print(list(r))

#reduce把一個函數作用在一個序列[x1, x2, x3, ...]上，這個函數必須接收兩個參數
# reduce把結果繼續和序列的下一個元素做累積計算，其效果就是：
# reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
#eg：求和
from functools import reduce
def add(x, y):
    return x + y
print(reduce(add,[1,2,3,4,5,6]))

#把序列[1, 3, 5, 7, 9]變換成整數13579
from functools import reduce
def fn(x, y):
    return x * 10 + y
print(reduce(fn,[1,2,3,5,7,9]))

##sorted()
print(sorted([36,5,-6,3,78]))
#[-6, 3, 5, 36, 78]

#sorted()函數也是一個高階函數，它還可以接收一個key函數
#來實現自定義的排序，例如按絕對值大小排序
print(sorted([36,-5,6,-3,78],key=abs))
#[-3, -5, 6, 36, 78]

#我們給sorted傳入key函數，即可實現忽略大小寫的排序
print(sorted(['bob','ABC','Zoo','Cread','Ca'],key=str.lower))
#輸出['ABC', 'bob', 'Ca', 'Cread', 'Zoo']

#要進行反向排序，不必改動key函數，可以傳入第三個參數
print(sorted(['bob','ABC','Zoo','Cread','Ca'],key=str.lower,reverse=True))

print(sorted([('Bob',75),('Csd',89),('Adf',99),('Adf',88)]))
#輸出[('Adf', 88), ('Adf', 99), ('Bob', 75), ('Csd', 89)]

2.匿名函數

print ( list(map(lambda x: x*x,[1,2,3,4,5,6,7,8])) )
#lambda x:x*x相當於定義一個函數,:前面的x表示函數參數

f=lambda x:x*x
print( f(5) )

#同樣，也可以把匿名函數作爲返回值返回
def bulidd(x,y):
    return lambda: x*x +y*y
f = bulidd(3,3)
print( f() )

3.偏函數

#int()函數還提供額外的base參數，默認值爲10。
#如果傳入base參數，就可以做N進制的轉換
print(int('12345',base = 8))
print(int('12345',8))

#可以定義一個int2()的函數，默認把base=2傳進去：
def int2(x,base = 2):
    return int(x,base)
print(int2('10000'))

#functools.partial就是幫助我們創建一個偏函數的，不需要我們自己定義int2()，
# 可以直接使用下面的代碼創建一個新的函數int2：
import functools
int2 = functools.partial(int,base=2)
print(int2('10000'))
#簡單總結functools.partial的作用就是，把一個函數的某些參數給固定住
#（也就是設置默認值），返回一個新的函數，調用這個新函數會更簡單。

八：面向對象編程

1.類和實例

#創建一個類，類是一種具有相同屬性和方法的抽象
#創建類需要使用class關鍵字，並且定義方法時，方法的第一個參數是self
class Student(object):
    #這點與C/C++、C#的語法不同，簡單區別下，定義類屬性需要在特殊方法__init__內部
    def __init__(self,name,score):
        self.name = name#這裏纔是類內的屬性，爲類屬性
        self.score =score#同樣的，這也是類屬性
    def fun(self):
        print("這就是類內定義一個類的方法")
    def print_name(self):
        print(self.name)
    def print_score(self):
        print(self.score)
    def get_grade(self):
        if self.score >=90:
            return 'A'
        elif self.score >=60:
            return 'B'
        else:
            return 'C'

#創建實例是通過類名+()實現的
bar = Student("ZCY",100)
bar.print_name()
bar.print_score()
print(bar.get_grade())

print(bar.score)#可以從外部訪問變量（相當於Public）

2.訪問限制

#如果要讓內部屬性不被外部訪問，可以把屬性的名稱前加上兩個下劃線__，
#在Python中，實例的變量名如果以__開頭，就變成了一個私有變量（private），
#只有內部可以訪問，外部不能訪問，所以，我們把Student類改一改：
class Student(object):
    def __init__(self,name,score):
        self.__name = name
        self.__score = score
    def print_score(self):
        print(self.__score)
    def print_name(self):
        print(self.__name)
    def get_name(self):
        return self.__name
    def get_score(self):
        return self.__score
    def set_score(self,score):
        self.__score = score
    def set_name(self,name):
        self.__name = name

bar = Student("ZCY",100)
bar.print_name()
print(bar.get_name())
bar.set_name("XJH")
print(bar.get_name())

#改完後，對於外部代碼來說，沒什麼變動，但是已經無法從外部訪問實例變量.__name和實例變量.__score了
#如果外部想訪問，我們加一個print_score()和print_name()方法就可以了,如上代碼
##如果外部想得到，我們加一個get_score()和get_name()方法就可以了,如上代碼
#如果外部想修改，我們加一個set_score()和set_name()方法就可以了，如上代碼

#並且以雙下劃線結尾的，是特殊變量，特殊變量是可以直接訪問的，不是private變量，
#所以，不能用__name__、__score__這樣的變量名。

3.繼承和多態

#繼承最大的好處是子類獲得了父類的全部功能
class Animal(object):
    def run(self):
        print('我是父類')
class Dog(Animal):
    def RUN(self):
        print('我是子類')

animal = Animal()
animal.run()

dog = Dog()
dog.run()

#覆蓋：如果子類父類裏面都有run()方法時，我們稱子類的run覆蓋了
#父類的run，在代碼運行的時候，總是會調用子類的run()
class Animal(object):
    def run(self):
        print('11')

class Dog(Animal):
    def run(self):
        print('22')
p=Dog()
p.run()#輸出22
pp=Animal()

#判斷一個變量是否是某個類型可以用isinstance()判斷：
print( isinstance(p,Animal)) #True
print( isinstance(p,list)) #False
print( isinstance(p,Dog)) #True
print( isinstance(pp,list))#False
print( isinstance(pp,Dog))#False
print( isinstance(pp,Animal))#True
#所以p時Dog類型的，還時Animal類型的

九：面向對象高級編程

1.使用__slots__

#創建一個class實例
class Student(object):
    pass
#然後實例綁定一個屬性
s = Student()
s.name = 'Michael'
print(s.name)

#給實例綁定一個方法
def set_age(self,age):# 定義一個函數作爲實例方法
    self.age=age
from types import MethodType
s.set_age=MethodType(set_age,s)# 給實例綁定一個方法
s.set_age(25)# 調用實例方法
print(s.age)# 測試結果

#但是，給一個實例綁定的方法，對另一個實例是不起作用的
s2 = Student()
#s2.set_age(25)#不能這樣寫

#爲了給所有實例都綁定方法，可以給class綁定方法：
def set_score(self,score):
    self.score=score
Student.set_score = set_score

#給class綁定方法後，所有實例均可調用：
s.set_score(100)
print(s.score)
s2.set_score(99)
print(s2.score)

#使用__slots__:限制實例的屬性
#使用__slots__:限制實例的屬性
class Student(object):
    __slots__ = ('name','age')

s = Student() # 創建新的實例
s.name = 'Michael' # 綁定屬性'name'
s.age = 25 # 綁定屬性'age'
#s.score = 99 # 綁定屬性'score'
#由於'score'沒有被放到__slots__中，所以不能綁定score屬性

#使用__slots__要注意，__slots__定義的屬性
#僅對當前類實例起作用，對繼承的子類是不起作用的

#除非在子類中也定義__slots__，這樣，子類實例允許
#定義的屬性就是自身的__slots__加上父類的__slots__

 

 

學習中……

 

 

 

 

番外：Python math包

#除非有說明，math的函數都返回浮點數
import math

print(math.ceil(5.7)) #上取整 輸出6
print(math.floor(5.6))#下取整 輸出5

print(math.factorial(3))#3的階乘 輸出6

print(math.gcd(2,4))#最大公約數 輸出2
print(math.gcd(0,0))#輸出0

print(math.sqrt(4))#平方根 輸出2。0

print(math.log(4,2))#log(x,y)表示x以y爲底的對數
print(math.log2(8))#返回 x 以2爲底的對數 輸出 3.0
print(math.log10(100))#返回 x 以10爲底的對數 輸出 2.0

print(math.pow(2,3))#輸出2的3次方

print(math.pi)#輸出3.141592653589793
print(math.e)#輸出2.718281828459045

print(math.sin(math.pi/2))#返回 x 弧度的正弦值。輸出1.0
#類似的還有math.tan(x) math.cos(x) 注意都是弧度
#math.asin() math.acos() math.atan()

print(math.degrees(math.pi/2))#將角度 x 從弧度轉換爲度數。 輸出90.0
print(math.radians(180))# 將角度 x 從度數轉換爲弧度。輸出3.141592653589793