000-愉快的開始

入門容易,學習難,代碼量少.

跨平臺: Windows, Mac OS, Linux, UNIX.

　　應用領域: 操作系統 WEB 3D動畫 企業應用 雲計算等等.

001-我和Python的第一次親密接觸

1.安裝
2. IDLE 是一個Python Shell:一個通過鍵入文本與程序交互的途徑.
3.print(‘text’), print(5+3), print(123+456), print(‘test’ +’text’ ), print(‘test’ * 8), print(‘test \n’ * 8)
4.上一條語句快捷鍵:Alt + p 下一條語句快捷鍵:Alt + n

002-用Python設計第一個遊戲

1.在IDLE中Ctrl + N 新建一個編輯器
2.寫入一個猜數字的小遊戲
3.Tab: 縮進 和 補全
4.Ctrl + S 保存
5.按F5運行
6.縮進很重要! 末尾有冒號,回車後會自動縮進.
7. 一個等號是賦值,兩個等號是判斷是否等於.
8.流程圖
9.BIF == Buile-in functions 內置函數
10.有多少個內置函數在IDLE中:dir(__bulitins__)
11.幫助:help(BIF_Name)

003-變量和字符串

1.變量名就像我們現實社會的名字,把一個值賦值給一個名字時,Ta會存儲在內在中,稱之為變量(variable),在大多數語言中,都把這種行為稱為”給變量賦值”或”把值存儲在變量中”.
但是在Python與大多數其他計算機語言的做法不同,他並不是把值存儲在變量中,而更像是把名字貼在值上邊.所以有些Python程序員會說Python沒有”變量”,只有”名字”.
2.變量可以運算:

f = 3

s = 8

t = f + s

print(t)

–> 11

換成字符串也是可以的.

3.使用變量要註意的地方:

(1)在使用變量之前,需要對其先賦值.
(2)變量名可以包括字母,數字,下劃線,但變量名不能以數字開頭.
(3)字母可以大寫或小寫,但大小寫是不同的.
(4)等號(=)是賦值的意思,是把右面的值賦給左面的變量名,不能寫反了
(5)變量名理論可以取任何合法的名字,但盡量要取一個專業點的名字:
4.我們所認知的字符串就是引號內的一切東西,我們也把字符串叫做文本.文本和數字是不同的.

5.要創建一個字符串,就要在字符兩邊加上引號,可以是單引號或者雙引號,但必須成對出現.
6.轉義符號用 \ –> ‘Let\’s go!’
7.但是要打印 ‘c:\now’ 文件路徑,可以用’c:\\now’也就是用轉義來轉義\但是這種方法如果有很多的\就不方便
8.對於上面的問題,我們就可以用原始字符串也就是 r ‘ test ‘的方法,但是要註意原始字符串的最後面是不能加上 \ 的解決辦法是什麽呢(我自己覺得可以字符拼接)
9.長字符串:要得到一個跨越多行的文本可以用三引號.
10.符號一定要用英文標點符號.
004-改進小遊戲
1.猜錯的時候程序應該給提示
2.只能猜一次,應該多點機會
3.每次運行程序,答案可以是隨機的
4.條件分支
(1)比較操作符: >, >=, <, <=, ==, != 反回 True或False 比較操作符左右要加空格
(2)分支語法:
if條件:
條件為真(True)執行的操作
else:
條件為假(False)執行的操作
5.while循環
(1)while 條件:
條件為真(True)執行的操作 (例如:while guess != 8:)
(2)別忘了冒號和縮進.
(3)and邏輯操作符 左右同時為True才為True
6.引入外援: random模塊
(1)我們寫的每個程序其實就是模塊
(2)random模塊裏有一個函數叫randint()會反回一個隨機整數.
例:random.randint(1,10) 生成一到十中的一個隨機整數.
(3)導入 import random

005-數據類型

1.字符串運算會拼接字符串
2.整型:python3整型和長整型和在一起了,長度不受限制. Python2裏是分開的.
3.浮點型:就是小數,區別就是有沒有小數點
4.e記法:就是科學戶數法(有正負 負就是往小正就是往大)
A = 0.000000000025
A –> 2.5e-11
b = 150000000000
b –>1.5e11
5..布爾類型:是一種特殊的整型.True Fales可以當成 0和1也可以用來計算.
True +true = 2
True+false = 1
True*false = 0
True/false 會報錯, 0 不能做為除數
但是 一般不用來計算.

一.如何相互轉換?
有BIF : int() str() float()
int():轉化為整數, a = ‘520’ b = int(a) b –> 520
也可以把浮點型轉換為整數,但是python會把後面的數直接砍掉,不會四舍五入.
不能用 a=’string’這種讓int轉換

float: a = ‘520’或者a=520 b = int(a) b –> 520.0

str(): 轉換為字符串.

不能用BIF當變量名.

二. 如何獲得類型的信息(判斷)
type(): 括號內寫要判斷的內容.會返回括號內的類型.

isinstance() :有兩個參數 一個是用來判斷的變量,一個是想要確定的類型
它會返回一個布爾值,如果符合判斷,為True 反之為Flase
a = ‘string’
isinstance(a,str)
–> True

isinstance(123456,str)
–> Float

更加建議用 isinstance()

006-常用操作符
+ : a= a+3 可以寫做 a+=3 | b = 3 b-=1 b –> 2
–
*
/
% : 求余數 5%2 –> 1 |11%2 –>1
** : 冪,也就是多少次方
// : 地板除 10//8 –> 1 | 3.0//2 –>1.0

例:
a = b = c = d = 10 –> a=10 b=10 c=10 d=10
a +=1 a–>11
b -=3 b–>7
c*=10 c–>100
d /=8 d–>1.25

伏優先級問題:最先括號,先乘除,再加減.
-3 * 2 + 5 / -2 -4
–> (-3)*2 + 5/(-2) -4
–> ((-3)*2)+(5/(-2)) -4
比較操作符(<,>)比邏輯操作符優先級高
3<4 and 4<5
(3<4) and (4<5)
必要的時候多加括號,增加代碼的可讀性.

冪運算比左面的高比右面的低
-3 **2 (正常來說 -3 * -3 應該等於 9)
–> -(3 ** 2)
–> -9

邏輯操作符
and 左面都為真 才為真
or 左或右為真 就為真.
not 左右都為假 就為真.

統計一下:

最高 ** 但有特殊性
然後 正負號
然後 * / //
然後 + –
然後 < > <= >= == !=
然後 not and or

007-支和循環1

一. 遊戲的組成和架構(打飛機遊戲)
1.進入遊戲就是進入一個大循環:只要不死直出飛機
2.分支 條件發生改變 進入另一個胡同昊
3.飛機都一樣,所以都是一個對象復制出來的.
框架:
1.加載背景音樂
2.播放音樂 單曲循環
3.我方飛機誕生

小飛機間隔變量 = 0
while True
if 用戶是否點了關閉 退出
break

間隔 += 1
if 間隔 == 50:
間隔 = 0
小飛機誕生
小飛機移動一個位置 從上往下
屏幕刷新

if 用戶鼠標移動
我方飛機中必位置 = 用戶鼠標位置
屏幕刷新

if 我方飛機與小飛機發生肢體沖突
我方掛,播放撞擊音樂
修改我方飛機圖案
打印game ove
淡出停止背景音樂

008-分支和循環2

90分以上為A,80-90分為B,60-80為C,60以下為D
寫一個程序,當用戶輸入分數,自動轉換為ABCD的形式打印.

答案:用if elif else 語句實現!

懸掛else? 在Python中是不可能的.

條件表達式(三元操作符,三目操作符)
幾元操作符,是指這個操作符有多少個操作數
例如 a = 1 這裏的 = 左右有兩個操作數,所以它就是一個二元操作符.
-1 減號當做負號時他就是一個一元操作符.
small = x if x<y else y 這就是一個三元操作符.
語法是:x if條件 else y
當條件滿足時,把x的值給了small,不成立時把y值給了small

斷言(assert)
assert是關鍵字, 稱為斷言
當這個關鍵字後邊的條件為假的時候,程序自動崩潰
並拋出AssertionError的異常
例子: assert 3>4
一般來說我們可以用它再程序中轉入檢查點,
當需要確保程序中的某個條件一定為真才能讓程序
正常工作的話,assert關鍵字就非常有用了.
tips: 這一般用來測試程序用.

009-分支和循環3

while循環:條件為真,一直循環.
while 條件:
循環體

for 循環,計算器循環:
for 目標 in 表達式(列表,元組):
循環體
例子:
a = ‘lvyang’
for i in a:
print(i, end=’ ‘) # 註意這裏的print end語句 表示輸出用什麽結尾

num = [‘a’,’bccc’,’bcf’,’dd’,’e’,’f’]
for each in num:
print(each,len(each)

range():
語法:range([strat,]stop[, step=1])
有三個參數,其中用中括號括起來的兩個表示這兩個參數是可選的.
-step=1 表示第三個參數的默認值是1.如果你不主動設置step就是1.
-rang這個BIF的作用是生成一個從start參數的值開始到stop參數的值
結束的數字序列.
range()是經常和for in一起的:
range(5)–> range(0,5)
list(range(5)) –> [0,1,2,3,4]
例子:
for i in range(5):
或
for i in range(2,9):
或
for i in range(1,10,2): –>第三個參數step是步長的意思.

兩個關鍵的語句:break 和continue
break:終止循環,並跳出循環體.
continue:終止本輪循環,並開始下一輪循環,註意,它在開始下一輪循環之前它會測試
下一輪循環的條件.只有下一輪循環為True的時候,它才會開始下一輪循環.如果不會的話
它會退出循環.

010-列表

所有類型都可以裝進去.
一,創建列表三種方式
1.創建一個普通列表:
member = [‘xx’,’oo’,’dd’,’cc’]
也可以 num = [1,2,3,4]
2.創建一個混合列表:
mix = [1,’ddd’,3.14,[1,2,3]] 也可以在裏面添加一個列表.
3.創建一個空列表
empty = []

二,向列表添加元素
1.append()方法 :member.append(‘oooxxx’) 只能添加一個元素. 添加到列表的尾部.
len(member)–>反回列表的長度
.後面是方法 屬於列表對象
2.extend()擴展,用一個列表擴展另一個列表.
member.extend([‘東奔西走’,12345,’大發尋’]) 把一個列表追加一列表的末尾.
3.insert()方法:有兩個參數,第一個代表在列表中的位置,第二個參數插入的元素.
會在第一個參數指定的位置,插入元素.
member.insert(1,’jj’)
位置是從0算起的,如果想放在第一個位置要寫0

011-列表2
一.從列表中獲取元素
1.member[0]獲取第一個
member[1]獲取第一個
想給member列表的第一和第二個元素調換位置
temp = member[0] 把第一的元素放在一個臨時變量裏
member[0]=member[1] 把第一個元素改成第二個元素
member[1]=temp 把臨時變量添加到第二個元素位置.
二.從列表刪除元素
1.remove()
member.remove(‘oo’) 參數是要刪除元素的名字
如果沒有給定的參數就會報錯
2.del
它不是列表的方法,是一個語句.
del member[1] 把第一個元素刪除.
del member 把整個列表刪除.
3.pop()
member.pop() 會刪除最後一個元素,並反回刪除元素的內容.
我們可的把刪除的內容賦值 name = member.pop() 這樣
pop()有一個參數,member.pop(索引)
三.列表切片(slice)
一次需要獲取多個元素.得到原列表的一個copy
member[:]
member[1:3]
member[:3]
member[2:]
member[:-1]

012-列表3
一.比較操作符
例:
ist1 = [123]
list2 = [234]
list1 > list2
例:
list1 = [123,456]
list2 = [234,123]
list1 > list2
tips:列表是從第0個元素開始比較的,如果第0個贏了那就贏了,不考慮後面的元素.
例:
list3 = list1 = [123,456]
(list1 < list2) and(list1 == list3) –>True
例:
list4 = list1 +list2
但是一般不要用,一般要用list.extend()更為規範.
例:
list1 + ‘大’ –>報錯
+號左右的對象的類型必須是一樣的.
例:
list1 * 3
例:
list3*=3 或 list3 *= 5
例:
123 in list3 –>True
‘233’ not in list3 –>false
例:
列表裏的列表可不可以呢?
lists = [123,[‘人’,’從’],456]
‘人’ in lists –>false
可以這樣
‘人’ in lists[1] –> True
lists[1][1] –>’從’

二.列表的BIF : dir(list)可以查到
1.count 計算列表中參數出現的次數.
list3.count(123)
2.index 索引,反回參數在列表中的位置.
list3.index(123)

list3.index(123,3,7) 後面的參數可以指定要找的範圍.
3.reverse() 原地翻轉.
list3.reverse()
4.sort() 用指定的方式對列表進行排序.
默認是從小到大
list6 = [4,3,2,5,9,23,32,0]
list6.sort() –>從小到大排
sort(reverse = false) –> list6.sort(reverse=True)
5.列表的copy
賦值不等於copy
復制粘貼,快捷方式的區別.
很容易出現錯誤.!

013-元組(tuple)

—裏面的參數,不可改變,在使用時和列表非常相似

1.創建:tuple1 = (1,2,3,4,5,6,7,8)
創建一個空元組: tuple2 = ()
2.訪問:tuple1[1]也可以 tuple1[5:] 或 tuple1[:5]
也可以copy一個列表 tuple2 = tuple1[:]
3.元組裏的元素不可以修改
註意: temp =(1) –> temp –> type(temp) –> <class ‘init’>
創建只有一個元素的元組,反回來的type其實是
init 認為它是一個變通變量
如果要創建一個只有一個元素的元組,temp = (1,)或temp = 1,
在元素的後面加一個逗號.

temp2 = 2,3,4,5 –> type(temp2) –> <class ‘tuple’>
創建多個元素的變量,就算沒有小括號也會得到元組

所以小括號不是關鍵,逗號才是關鍵.

例:
8 * (8) –> 64
8 * (8,) –> (8,8,8,8,8,8,8,8) 因為是元組了

4.更新和刪除一個元組
temp = (‘a’,’b’,’c’,)
temp = temp2[:2]+(‘dd’,)+temp[2:]
tip:要刪除某一個元素是不可能的,只可以用上面的方法重組
要刪除整個元組可以用 del 語句 : del temp
一般不用 del 語句,因為有內在回收機制
5.元組相關的操作符
+ 拼接
* 重復
>,<
in,not in
and or not

014-字符串
–切片也可有用在字符串上:str1 = ‘123456789’ –>str1[:5] 也可以用索引取出.
–字符串和元組一樣也不能隨意修改,如果實在想修改,參照上面的元組.
–相關操作符和元組列表基本一樣

字符串的方法
1. captalize — 第一個字符大寫
2. casefold — 把整個字符串改為小寫
3. center(50) — 把字符串居中,並使用空格填充至長度width的新字符串
4. count(‘str’) — 查找字符串中有幾個’str’，還有可選參數 start和end
5. encode()
6. endswith(‘x’) — 檢查是否是‘x’結束,也有可選參數start和end
7. expandtabs() — 把’\n’ 的空格轉換成默認為8長度‘(可指定)’的tab,也有可選參數start和end
8. find() — 檢測括號內容是否包含在字符串中,有,反回索引.否則返回-1,start和end
9. index() — 跟find方法一樣,不過如果括號裏的內容不在string中會產生一個異常.
10. isainum() — 如字符串至少有一個字符並且所有字符都是字母或數字 則反回True,否則返回false
11. isalpha() — 如客串至少有一個字符並所有字符都是字母則返回True,否同則反回false
12. isdecima() — 如果字符串只包含十進制數字則返回True,否則返回false
13. isdigit() — 如果字符串只包含數字則返回True,否則返回false
14. islower() — 小寫,
15. isnumeric() — 如果字符串中只包含數字字符,則反回True
16. ispace() — 如果字符串中只包含空格返回True
17. istitle() — 如果字符串是標題化(首字母大寫)返回True
18. isupper() — 如字符串中至少包含一個區分大小寫的字符,並且這些字符都是大寫,則返回True
19. join(sub) –以字符串作為分隔符,插入到sub中所有的字符之間.
20. ljuest(width) — 返回一個左對齊的客串,並使用空格填充至長度為width的新客串
21. lower() — 轉換字符串中所有大寫為小寫.
22. lstrip() — 去年字符串左邊的所有空格
23. partition(sub) — 找到
太多了 跳~
/t 就是一個tab

015-字符串格式化 format
例1: ‘{0} love {1},{2}’.format(‘lv’,’ren’,’zhen’) 位置參數
例2: ‘{w} love {t},{y}’.format(w=’lv’,t=’ren’,y=’zhen’) 關鍵字參數
例3: ‘{0} love {t},{y}’.format(‘lv’,t=’ren’,y=’zhen’) 位置和關鍵字一起用,但是一定要位置在關鍵字之前
例4: ‘{{0}}’.format(‘打印’) –> {0} 要打印{} 就用這種方法 大括號轉義大括號
例5: ‘{0:.1f}{1}’.format(2.688,’GB’) :冒號表示格式化符號的開始,保留一位小數四舍五入.
格式化操作符:
1.格式化字符及ascii碼 ‘%c %c %c’ %(97, 98, 99): –> a b c
2.格式化字符串 ‘%s’ % ‘abc’:
3.格式化整數 ‘d’
4.格式化無符號八進制數 %o
5.格式化無符號十六進制數 %x
6.格式化無符號十六進制數(大寫) %x
7.格式化定點數,可指定小數點後的精度 %f (默認精確到6位)
8.用科學計數法格式化定點數 %e
9.和%e一樣,用科學計數法格式化定點數 %E
10.%g 根據值的大小決定使用%f或%e
11.%G 作用同%g 根據值的大小 決定使用%f或者%e
格式化操作輔助命令:
m.n m是顯示 最小部寬度,n是小數點後面的位數 %5.1f 或 %.2e %27.658
– 用於左對齊
+ 在正數前面顯示加號
# 在八進制數前百顯示(‘ 0′)在十六進制數前面顯示’0x’或’0X’ 用於直接告訴你顯示的是多少進制
0 顯示的數字前面用0代替空格.

字符串轉義字符含義
\’ 單引號
\” 雙引號
\a 發出系統響鈴聲
\b 退格符
\n 換行符
\t 橫向制表符 tab
\v 縱向制表符
\r 回車符
\f 換頁符
\o 八進制數代表的字符
\x 十六進制數代表的字符
\0 表示一個空字符
\\ 反斜杠

016-序列!
1.列表.元組和字符串的共同點
都可以通過索引得到每一個元素
默認索引值總是從0開始
可能切片
有很多共同的操作符 * + 等
2.序列的BIF
list() 把可叠代對象轉換成列表
list()空列表
list(iterahle)帶一個叠代器參數
tuple() 把可叠代對象轉換為元組
和list()一樣
str() 把對象轉換為字符串
len() 反回長度
max() 反回序列或者參數中的最大值 如果參數是字符串就是比較ascii碼
min() 和max()相返 反回最小值
–使用max()和min()方法必須保證參數中的數據類型是統一的
sum(iterable[,start=0]) 反回序列iterable和可選參數start的總和 也只能整數或浮點數
sorted() 排序 和list的sort是一樣的.
reversed() 比list的reverse多了個d.會反回一個個叠代器對象. 翻轉
enumerate() 枚舉 生成每個元素的索引和值的元組 [(0,’a’),(0,’b’)]
zip() 反回由個個參數 a = [1,2,3,4,5,6,7,8] b=[4,5,6,7,8] zip(a,b) –>[(1,4),(2,5),(3,6),(4,7),(5,8)]
017.函數-Python的樂高積木
–函數 對象 模塊
def MyFirstFunction():
print(‘hello.world!’)
print(‘這是第一個函數!’)
運行時會把def直接拋進內存,在調用的時候就會往上尋找,然後執行.如果沒有找到就會報錯

參數功能:
def MySecondFunction(name):
print(name+’我愛你’)
調用的時候 加入參數就可以了

多個參數用逗號隔開就可以了,支持很多參數(盡量不要太多,寫好文檔)
def add(num1, num2):
result = num1 + num2
print(result)

函數反回:
用關鍵字return 就可以了
def add(num1, num2):
return(num1 + num2)

18-函數 靈活即強大(參數)
一. 形參(parameter)和實參(argument)
1.函數定義過程中的name是叫形參(因為他只是一個形式,表示占據一個參數位置)
print(‘傳遞進來的’+name+’叫做實參,因為他是具休的參數值.’)
2. MyFirstFunction(‘hehe’)
傳遞進來的小甲魚叫做實參,因為ta是具體的參數值.
二.函數文檔 給函數寫文檔!會做為函數的一部分存儲起來.
MyFirstFunction.__doc__
就可以調出函數的說明.也可以用help()來查看
三.關鍵字參數
為了怕搞錯順序
def SaySome(name, words):
print(name+’>>>’+words)
就是在調用的時候寫上參數的名字: SaySome(name = ”, words = ‘ ‘)
四.默認參數
定義函數時給參數一個默認值. name = ” , words = ”
如果給定參數則使用給定的參數.
五.收集參數(可變參數)
在參數前面加上*號就可以了
def test(*params): # 加了*號就可以給定很多參數
print(‘參數的長度是:’, len(params))
print(‘第二個參數是:’, params[1])
!!如果在收集參數後面還要加參數就要使用關鍵字參數,並為關鍵字參數設置默認參數.
否則參數就都進入到收集參數中了,就會報錯
print()BIF的第一個參數就是收集參數.後面的參數也都有默認值

19.函數-我的地盤聽我的
一.函數與過程
–Python嚴格來說只有函數沒有過程.
def hello():
print(‘hello world’)
temp = hello()
print(temp) –> None
type(temp) –> class’NoneType’
二.反回函數
可以返回多個值(可以反回一個列表,也可以用逗號隔開會反回一個元組.)

三.變量的作用域(局部變量*(Local Variable),全局變量(Global Variable))
1.局部變量:
def discounts(price, rate):
final_price = price * rate
old_price = 88 # 這裏試圖修改全局變量.
print(‘修改後old_price的值是:’, old_price)
old_price = float(input(‘請輸入原價:’))
rate = float(input(‘請輸入折扣率:’))
new_price = discounts(old_price, rate)
print(‘修改後的old_price的值是:’, old_price)
print(‘打折後的價格是:’,new_price)
在函數外面找不到函數內定義的參數,變量,函數,參數內的變量作用域只在函數中
2.全局變量
在函數在面定義的變量就是全局變量.他們的作用域就是整個代碼塊.也就是說在函數內也是可以訪問的
使用全局變量要千萬小心,在def中盡量不要修改全局變量
因為如果在函數中試圖修改全局變量的話Python會自動創建一個新的局部變量,名字和全局變量是一樣的(屏蔽保護機制)
所以會出現當時改了是改了,但是在外面的話重新訪問會還是改之前的內容.
20.函數-內嵌函數和閉包.
一.Global關鍵字可以更改全局變量(盡量不要用!!!)
二.內嵌函數 函數內部創建另一個函數
例子
def fun1():
print(‘fun1 runing….’)
def fun2():
print(‘fun2 runing ….’)
fun2()
使用內嵌函數後,只有fun1可以調用fun2.
三.閉包(編程範式)天才程序員使用的語言
def funx(x):
def funy(y):
return x*y
return funy
i = funx(8) –>function –> i(5) –> 40或者也可以funx(8)(5)
如果在一個內部函數裏,對在外部作用域在變量進行了引用,那麽這個內部函數就是一個閉包.

def fun1():
x = 5
def fun2():
x*=x
return x
return fun2()
調用後會錯誤,因為fun2在調用x的時候等同於要更改全局變量.所以就會錯誤,如何解決呢?:
def fun1():
x = [5]
def fun2():
x[0]*=x[0]
return x[0]
這各解決方式就是把數據存放在容器中.就可使用了.
還有一個關鍵字:nonlocal 使用的方法和上面的一樣.

21.函數-lambda表達式(匿名函數)
一.lambda表達式
def ds(x):
return 2 * x + 1
可以寫為: x:2*x+1
那麽兩個參數呢?:
def add(x, y):
return x+y
可以寫為: lambda x,y:x+y
lambda表達式的重要作用:
1.Python在寫一些執行腳本時,使用lambda就可以省下定義函數過程,
比如說我們只是需要寫個簡單的腳本來管理服務器時間,我們就不需要
專門定義一個函數然後再寫調用,使用lambda就可以使得代碼更加精簡.
2.對於一些比較抽象並且整個程序執行下來只需要調用一兩次的函數,
有時候給函數起個名字也是上比較頭疼的問題,使用lambda就不需要考慮
命名的問題了.
3.簡化代碼的可讀性,由於普通的屌絲函數閱讀經常要跳到開關def定義部分,
使用lambda函數可以省去這樣的步驟.
二.兩個牛逼的BIF
1.filter()過濾器. 用法:filter(function or None, iterable)
例子:
filter(None,[1,0,false,True]) –> fun –>[1,True] 返回為真的內容.
篩選奇數的過濾器:
def add(x):
return x % 2
temp = range(10)
show = filter(odd, temp)
list(show)–>[1,3,5,7,9]
給合上面內容可以寫為:
list(filter(lambda x:x%2,range(10)))
2.map() 映射 參數(函數,叠代)
list(map(lambda x:x*2,range(10)))

22-遞歸
–普通程序員使用叠代,天才程序員使用遞歸.(在恰當的地方使用遞歸.)
–必須掌握但是不要總用.它是一個臺階,須要掌握,但是有危險性.而且它很消耗時間和空間.
–Python默認遞歸深度是100層(可調) import sys –> sys.setrecursionlimit(10000000)
例子:
def recursion():
return recursion()
會一直調用 錯誤
例子:(正確)
寫一個階乘的函數:
非遞歸版本:
def factorial(x):
result = x
for i in range(1,x):
result *= i
return result
遞歸版本:
def factorial(x):
if n == 1:
return 1
else:
return n *factorial(n-1)
1.調用函數自身 2.設定了函數自身的反回值.

遞歸詳解:
factorial(5) = 5 * factorial(4)
factorial(4) = 4 * factorial(3)
factorial(3) = 3 * factorial(2)
factorial(2) = 2*factorial(1)
factorial(1) = 19 (return)
1.漢諾塔
2.樹結構定義
3.謝爾賓斯基三角形.
遞歸略 以後補

25-字典1
–字典不是序列類型,是映射類型.映射,建立關系
–鍵(key)
–值(value)
每一對鍵值組合稱為:項
brand = [‘李寧’,’耐克’,’阿迪’]
slogan = [‘一切皆有可能’,’just do it’,’impossible is nonthing’]
–>print(‘阿迪口號:’slogan[brand.index[‘阿迪’]] 麻煩
用字典:
dict1 = {‘李寧’:’一切皆有可能’,’耐克’:’just do it’,’阿迪’:’impossible is nonthing’}
print(‘李寧的口號是:’,dict1[‘李寧’])

dict2 = {1:’one’,2:’two’,3:’three’}
–>dict2[2]

dict3 = {} 空字典
或 dict() 創建空字典
dict()簡單用法: dict5 = dict(((‘f’,70),(‘c’,67),(‘s’,115)))
用對應關系創建字典.
dict6 = dict(呂洋=’哈哈’) 前面的key不能加引號

直接給字典裏的鍵賦值,如果存在改變,如果不存在創建.
dict7[‘呂洋’] = ‘哈哈哈哈哈哈’

26- 字典2
字典的內建方法:
1.fromkeys()
dict1() = {}
dict1.fromkeys((1,2,3))
dict1.fromkeys((1,2,3),’number’)
dict1.fromkeys((1,2,3),(‘1′,’2′,’3′)錯的 不會自動賦值
dict1.fromkeys((1,3),’數字’)錯的 不能批量修改,而是重新創建一個新字典
2.訪問字典的方法 key,values,items
dict1 = dict.fromkeys(range(32),’贊’)
for eachkey in dict1.keys():
print(eachkey) 會自動打出key values同理

for eachitem in dict1.items():
print(eachitem)
用元組把 key和values
3.key是否在dict中
get方法
dict1.get(32) 如果沒有會返回None
dict1.get(32,’目有’) 如果沒有會返回 目有

也可以用成員操作符:
32 in dict1 –> Flase
31 in false –> True

4.清空 dict
dict1.clear()
5.copy方法 淺拷貝
a = {1:’one’,2:’two’}
b = a.copy()
c = a
id(a)
id(b)
id(c)
淺拷貝和直接賦值不一樣
c[3]=’tree’
c
a
b
6.pop() 和 popitem()
a.pop(2)
a.popitem()

7.找不到自動添加
a.setdefault(‘哈哈’)
8.update 用一個字典或映射關系去更新另一個字典
b={‘i’:1}
a.update(b)

27-集合 無序!,去重 不能索引
num = {}
type(num) –>’dict’
num2 ={1,2,3,4,5}
type(num2) –> ‘set’

num2 = {1,1,1,1,1,2,2,2,,2,,2}
–> {1,2}
1.創建的兩種方法
用{} 把數字 括起來.
set() : set1 = set([1,1,1,1,2,2,2,2,2,2])
2.如何訪問set中的值
for 打印
in 方法 1 in num1
3.num2.add(9) 添加
4.num2.remove(9) 刪除

frozen 凍結的,設置一個不可變set
num3 = frozeset([1,2,3,666])
這種set不能添加

28-文件-想輸出.
1.打開文件
使用 open 打開文件.
help()

小甲魚Python3筆記