python學習記錄

print() 輸出數字 字串 含有運算子的表示式 print('hello','wolrd') 不進行換行輸出

為什麼轉義字元\t有時候是三個空格 有時候是四個空格
需要轉義字元在字串中不起作用時 print(r'hello \n wolrd') 在前面加R或r 但最後一個字元不能是\ 可以是\

識別符號和保留字

import keyword
print(keyword.kwlist)

變數

name='wangXu'
print(name)

變數的三部分 1標示（記憶體地址）（內建函式id()）2型別（資料型別）（內建函式type()）3值（具體資料）
變數名多次賦值後 會指向新的空間

int float str bool 

str 加 單引號

整數型別預設十進位制 0b表示二進位制 0o表示八進位制 0x表示十六進位制
浮點數型別計算不精確性 需要精確時 匯入模組

from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))

bool值可以轉成整數計算

f1=True
print(f1+1)

str可以使用單引號 雙引號 三引號來定義 三引號可以用三個單引號或者三個雙引號
單引號和雙引號的定義只能定義在一行裡 三引號的定義可以分在多行來寫 輸出的時候也會多行輸出

name='張三'
age='20'
print('我叫'+name+'今年'+age+'歲')  #加號是連線符 age是int型別 不能和str型別連線 需要型別轉換
print(我叫'+name+'今年'+(str)age+'歲')

float型別轉換為int型別時只轉換小數點之前的數
str轉換為int型別時，只有當str是數字串時才可以轉換 而且必須不是小數串 別的時候會報錯
str轉換成float型別時，str不能是非數字串，整數後面會加上.0

輸入函式input()

a=input('請輸入一個加數')
b=input('輸入另一個加數')

print(a+b)
#會輸出a和b的連線之後的字串
#因為從鍵盤輸入進來的都是字串型別 即str型別 所以此處的加號起了連線作用
#解決方法
a=input('請輸入一個加數')
a=int(a)
b=input('輸入另一個加數')
b=int(b)
print(a+b)
#或者
a=int(input('請輸入一個加數'))
b=int(input('輸入另一個加數'))
print(a+b)

運算子

加減乘數跟//
//是整除運算 只取除了之後的整數部分 沒有四捨五入
**是冪運算
一正一負的整除運算會向下取整

print(9//4)  #2
print(9//-4) #-3 

取餘運算 餘數=被除數-除數*商

解包賦值

a,b,c=20,30,40
a,b=b,a #交換a,b的值

布林運算子

and or not in not in
print(a==1 and b==2) #當兩個運算數都為True時 結果為True
print(a==1 or b==2)  #只要有一個運算數為True 結果為True
f = true
print(not f) #not 對bool型別的運算元取反

s='hello world'
print('w' in s) #True
print('k' not in s) #True

運算子優先順序

算術運算子>位運算>比較運算>bool運算(and or)>賦值運算

pass語句 在沒有想好程式碼怎麼寫的時候使用 相當於一個佔位符

rang()的三種建立方式

r = range(10) #預設從0開始 預設相差1成為步長
r = range(1, 10) #指定了起始值 從1開始 到10結束 但是不包括10 預設步長為1
r = range(1,10,2) #從1開始 到10結束 步長為2
print(list(r))
#判斷指定的整數在序列中是否存在 in , not in
print(10 in r)
print(10 not in r)
#range型別的優點 不管range物件表示的整數序列有多長 所有range物件佔用的記憶體空間都是相同的
#因為只需要儲存start stop 和 step 只有當用到range物件時 才會計算序列中的相關元素

a,sum = 0,0
while a<5:
    sum+=a
    a+=1
print(sum)    


sum=0
for item in range(1,101):
    if not bool(item%2)
        sum+=item

二重迴圈中 break和continue 只控制本層迴圈

列表可以儲存N個元素 程式可以方便地對這些資料進行整體操作，相當於其他語言中的陣列

#建立列表的第一種方式 使用[]
list=['hello','world',98]
print(id(list),type(list),list)
#第二種方式 使用內建函式list()
list2=list(['hello','world',98])

索引對映唯一一個資料
可以儲存重複資料
任意資料型別混存
根據需要動態分配和回收記憶體

#列表的查詢操作
list=['hello','world',98,'hello']
print(index('hello')) #如果存在重複元素 只會返回第一個重複元素的索引
print(index('hello',1,3)) #在指定範圍內查詢元素
#當查詢不到時會出現錯誤ValueError
#獲取單個元素時 根據正向索引或者反向索引
#獲取列表中的多個元素
lst=[10,20,30,40,50,60,70,80]
print(lst[1:6:1]) #start stop step 預設step=1 預設start=0
print(lst[1:6:]) #最後冒號不寫也可以
print(lst[:6:1])
print(lst[1::1]) #stop預設為最後+1
#判斷指定元素在列表中是否存在
#in not in 返回bool型別


#列表元素的增加操作
#append() 在列表末尾新增一個元素 
#extend() 在列表末尾至少新增一個元素
#insert() 在列表的任意位置新增一個元素
#切片 在列表的任意位置新增至少一個元素

lst=[10.20,30]
lst.append(100)
lst2=['hello','world']
lst.extend(lst2)
lst.insert(1,90) #把1的位置加上90 後續元素向後移
lst3=[True,False,'hello']
lst[1:]=lst3 #把0後面的全部切掉 換成lst3的所有元素


#列表元素的刪除操作
#remove() 一次刪除一個元素 重複元素只刪除第一個 元素不存在則報錯ValueError
#pop() 刪除一個指定索引位置上的元素 索引不存在則IndexError 不指定索引的話則刪除最後一個元素
#切片 一次至少刪除一個元素
#clera() 清空列表
#del 刪除列表

lst[1:3]=[] #會刪除1-3之間的元素 
print(lst)
del lst #將列表物件刪除


#列表元素的修改操作
lst[2]=100
lst[1:3]=[300,400,500,600]


#列表的排序操作
lst.sort()
lst.sort(reverse=Ture) 降序排序 false升序
sorted(lst) #會產生新的列表物件 原列表不會變化
sorted(lst,reverse=False)


#列表生成式
# i*i for i in range(1,10)
new_list=[i*2 for i in range(1,6)]
new_list=[2,4,6,8,10]

字典以鍵值對的方式儲存資料 是一個無序的序列 也是可變序列

 #字典的建立
 #1使用花括號
 scores={'張三':100, '李四':50}
 #2使用內建函式dict()
 stuent=dict(name='jack', age=20)
 #空字典
 d={}


#字典中元素的獲取 
#第一種
print(scores['張三'])
#第二種
print(scores.get('張三'))

方括號沒找到時會報錯 get會輸出None 可以設定預設的Value

#判斷 in not in
print('張三' in scores)
#刪除
del scores['張三']
print(scores)
scroes.clear() #清空
#新增
scores['陳六']=98
#修改
scores['張三']=60
#獲取所有的key
keys=scores.keys()
print(keys)
print(list(keys)) #將所有的key組成的檢視轉成列表
values=scores.valuse()
print(valuse)
print(list(valuse))
items=scores.items()
print(items) 
print(list(items)) #轉換之後的列表元素是又元組組成的
#字典元素的遍歷
for item in scores:
    print(item,scores[item],scores.get[item])

字典的鍵值不允許重複 但Value可以重複
字典是一種空間換時間的資料結構

#字典的生成式
items['Fruits','Books','Others']
prices=[96,78,85]
d={item.upper():price for item,price in zip(items,prices)}
print(d)

字串跟元組是不可變序列
改變了之後會改變地址
但字典跟列表新增修改刪除之後不會改變物件的地址

#元組的建立方式 
1
t=('python','hello','world')
t='python','hello','world'
#只包含一個元素的元組建立時需要逗號和小括號 不能省略
2
t=tuple(('python','hello','world'))
#元組的遍歷
for item in t:
    print(item) 

#集合的建立方式
#第一種建立方式
s={2,3,4,5,5,6,7,7}
#集合中的元素不允許重複
#第二種建立方式 使用內建函式set
s1=set(range(6))
s1=set([1,2,3,4,5,6])
s1=set((1,2,3,4,5,6))
s1=set('python')
s1=set({1,2,3,4,5,6})
d1=set() #空集合
#判斷操作 in not in
print(10 in s)
#新增操作
s.add(80)  #一次新增一個元素
s.update({200,300,400})  #一次至少新增一個元素
s.update([200,300,400])
s.update((200,300,400))
#刪除操作
s.remove(100)
s.remove(500) #keyError
s.discard(500) #如果有就刪除 沒有也不會報錯
s.pop() #刪除任意的元素 不能指定引數
s.clear() #清空集合元素


#集合之間的關係
s={10,20,30,40}
s2={30,40,20,10}
print(s==s2) #True 因為集合是無序的
s1={10,20,30}
s2={10,20}
print(s2.issubset(s1)) #True 子集關係
print(s1.issuperset(s2)) #True 超集關係
print(s2.isdisjoint(s1)) #True 交集


#集合的數學操作 
#1交集
s1={10,20,30,40}
s1={20,30,40,50}
print(s1.intersection(s2)) 
print(s1 & s2) #和上面一樣的
#2交集
print(s1.union(s2))
print(s1 | s2)
#3差集
print(s1.difference(s2))
print(s1-s2)
#s2-s1的輸出跟s1-s2的輸出不一樣
#對稱差集
print(s1.symmetric_difference(s2))
print(s1^s2) #交換順序 輸出一樣
#集合生成式
s={i*i for i in fange(10)}
#無序

字串的駐留機制

對相同的字串只保留一份拷貝 後續建立相同字串時 不會開闢新的空間 而是把該字串的地址賦給新建立的變數(多個相同的字串會指向相同的地址)

駐留機制的幾種情況

1字串的長度為0或者1時
2符合識別符號的字串
3字串只在編譯時駐留 不在執行時駐留
4[-5,256]之間的數字

#字串的查詢操作
#index() rindex()
#find() rfind()
print(s.index('lo'))
print(s.find('lo'))
print(s.rindex('lo'))
print(s.rfind('lo'))
#一般使用find方法 不會出現異常 找不到會返回-1
#帶r的是查詢子串最後一次出現的位置

#字串大小寫轉換操作
#upper() lower() swapcase() capitalize() title()
#所有全都轉換大寫 所有全都轉換成小寫 都會產生一個新的字串物件
#把大寫轉換成小寫 小寫轉換成大寫 
#把第一個字元轉換成大寫 其餘字元轉換成小寫
#把每個單詞的第一個字元轉換成大寫 每個單詞的其餘字元轉換成小寫

#字串內容對齊操作
#center() 居中 第一個引數指定寬度 第二個引數指定填充符 預設空格
#ljust() rjust() 
#zfill() 右對齊 用0填充 只接受一個引數寬度

#字串分割操作
s='hello world python'
lst=s.split()  #從左側開始分割 沒有引數sep時預設分隔符為空格
s1='hello|world'
lst=s1.split(sep='|')
lst=s1.split(sep='|',maxsplit=1) #最大分割次數
lst=s.rsplit() #從右側開始分割

#字串的判斷操作
#字串的其他操作
s='hello python'
print(s.replace('python','Java'))
#可以指定最大替換次數

函式

#函式的建立
def calc(a,b):
    c=a+b
    return c
answer=calc(10,20)    
result=calc(b=10,a=20) # =左側的變數名稱稱為關鍵字引數

#函式呼叫過程中 進行引數傳遞
#如果是不可變物件 在函式體的修改不會影響實參的值
#函式返回多個值時，結果為元組
def fun(*arg): #使用指標定義個數可變的位置形參 結果為一個元組
    print(arg) #可變的位置引數 只能是1個
def fun(**arg): #使用**定義個數可變的關鍵字形參 結果為一個字典
    print(arg)   #需要關鍵字 關鍵字引數也只能是1個
    #兩個混起來定義是可以的
def fun(*arg,**arg): #要求位置形參放在關鍵字形參之前

def fac(a):
    if a==1
        return 1
    else 
        return a*fac(a-1)
        
def fib(n):
    if (n==1)
        return 1
    elif (n==2) 
        return 1
    else 
        return fib(n-1)+fib(n-2)