“”"
1.安裝軟件
2.環境變量的配置
變量名 變量值
Path 應用程序所在的路徑(可執行的應用程序 xxx.exe 所在的文件夾)
3.DOS常用命令的使用
3.1 盤符切換
盤符:
3.2 進入文件夾
cd 路徑
3.3 展示文件夾
dir
tree
3.4 清除屏幕
cls
3.5 自動補全名稱
tab
4.變量
定義(在定義時,要給出初始值) 初始化
重新賦值
5.標識符(變量名)
要求:
可以有字母(包含中文),數字,下劃線
數字不能開頭,不能爲系統的關鍵字,大小寫敏感
關鍵字(保留字/敏感字)
35個
查看方式:
import keyword
print(keyword.kwlist)
如何更好的命名:
1.見名知意
2.駝峯命名法
大駝峯 MaxValue
小駝峯 maxValue
下劃線連接 max_value
python中的數據類型:
數值類型:bool,int,float,complex
字符串:str
複合類型:list,tuple,dict,set
運算符:
優先級以及結合性
數學運算符
+
-
*
/
//
%
**
賦值運算符
簡單的賦值
a = 1
複合的賦值
+=
-=
*=
/=
%=
**=
//=
a %= b ==>>> a = a % b
比較運算符
操作數(一般情況下,要求類型一致),比較結果(bool)
>
<
>=
<=
==
!=
age = 10
8 < age < 100
邏輯運算符
and
要求兩個條件都滿足,結果爲True
or
要求兩個條件有一個滿足,整個結果就爲True
not
如果條件爲真,加上not 就變成假
“”"
a = 0
v = ‘a’ > 10 # TypeError: ‘>’ not supported between instances of ‘str’ and ‘int’
print(v)
“”"
數值類型之間類型轉換:
1.強制轉換
由高到低的轉換,需要強制轉換
2.自動轉換
由低到高這時候的類型轉換屬於自動轉換
bool < int < float < complex
bool
int
float
complex
其他類型之間的轉換:
常用的轉換功能:
int() 轉換爲整數
float() 轉換爲小數
str() 轉換爲字符串
chr()
將unicode編碼值 轉換爲其對應的字符串
ord()
得到字符串對應的unicode編碼值
兩個函數可以實現互逆操作
eval()
將字符串轉數字的時候,會根據字符串是整型,還是小數來進行自動匹配
list()
tuple()
set()
“”"
# # 自動轉換
# x = True
# a = 1
# b = 2.5
# c = a + b
# print(type(c))
# print('---------------')
# d = x + a
# print(type(d))
# print('---------------')
# e = x + b
# print(type(e))
# print('---------------')
# # 複數 實部+虛部
# y = 2 + 3j
# print(type(y))
# z = a + y
# print('--------======')
# print(type(z))
# print(z)
#
# print('**'*30)
# # 強制轉換
# g = int(b)
# print(type(g))
# h = bool(b)
# print(type(h))
# ch = chr(20002)
# ch = chr(65)
# ch = chr(97)
# print(ch)
# print(type(ch))
# v = ord('宋')
# v = ord('A')
# print(v)
# str1 = '123'
# str1 = '123.5'
str1 = '[1,2,3]'
# 將字符串轉換爲整數
# v1 = int(str1)
# v1 = float(str1)
v1 = eval(str1)
print(v1)
print(type(v1))
“”"
\n 換行
輸出:
print(要輸出的內容)
換行的控制問題
print(‘xxx’,end = ‘’)
格式化的輸出:
print('name:%s age:%i')
%s:表示字符串
%i/%d:表示整型
%f:表示小數,默認保留小數點後6位,最後一位四捨五入
%g: 可以表示整數,也可以保留小數,如果是小數處理的時候,只保留認爲有意義的數據
輸入:
v = input(‘輸入提示’)
不論輸入的是什麼類型的數值,變量v接收到的值,都是str類型
“”"
# name = '小明'
# age = 18
# tel = 13800000000
# print('我叫%s,今年%i歲 手機號:%s,風華正茂,玉樹臨風'%(name, age, tel), end='\n')
# print('我叫%s,今年%i歲,風華正茂,玉樹臨風'%(name, age), end='\n')
# print(f'我叫{name},今天{age}歲,手機號:{tel},風華正茂,玉樹臨風',end='\n')
#
# a = 10
# print('a = %f'%a)
# print('a = %.2f'%a)
#
# PI = 3.1415925535897
# print('PI=%f'%PI)
#
# # b = 2.50000000
# # b = 2.511111111111
# b = 10.0
# print('b=%g'%b)
# name = input('請輸入你的姓名')
# print(type(name))
# print(name)
# age = input('請輸入你的年齡')
# print(type(age))
# print(age)
需求:從鍵盤輸入兩個變量a,b,求和,並打印
a = input('請輸入變量a的值')
b = input('請輸入變量b的值')
c = int(a) + int(b)
print(type(c))
print(f'和爲:{c}')
“”"
變量 組詞
語句 造句
函數 一段作文
類 整篇文章
語句結構:
順序結構
從上往下,從左往右,依次執行
分支結構
案例練習:
未成年人上網 (網咖)
骰子大小 1-6 [1-3] [4-6]
隨機模塊的使用
import random
n = random.randint(a,b)# 生成a-b之間的隨機數,包含a跟b
用戶登錄
默認註冊好的用戶名
acc = ‘abc’
pw = ‘123’
輸入用戶名,輸入密碼
if 用戶名對 同時 密碼也對:
登錄成功
判斷結構(向左走,向右走)
1.單分支
2.雙分支
3.多分支
循環結構
重複(鬼打牆)
“”"
順序結構
# print('HelloWorld1')
# print('HelloWorld2')
# print('HelloWorld3')
從鍵盤你的年齡,根據年齡來判斷是否可以上網
# age = input('請輸入你的年齡')
# # 數據類型轉換的問題
# age = int(age)
# if 18 <= age <= 100:
# # if age >= 18 and age <= 100:
# print('xx網咖歡迎您')
#
# if age < 18 or age > 100:
# print('回家洗洗睡')
需求:生成隨機數,判斷大小問題
import random
n = random.randint(1,6)# 1 <= n <= 6
print(n)
if 1 <= n <= 3:
print('小')
if 4 <= n <= 6:
print('大')
“”"
註冊用戶名,密碼
輸入用戶名,密碼,完成校驗登錄
雙分支語法:
if 條件:
條件成立執行的代碼
else:
條件不成立執行的代碼
需求:根據年齡上網問題: 改成雙分支的判斷形式
需求:骰子點數大小問題,改成雙分支的判斷形式
“”"
註冊
usename_register = input('請輸入註冊的用戶名:')
password_register = input('請輸入註冊的密碼:')
# 驗證登錄
username_login = input('請輸入之前註冊的用戶名:')
password_login = input('請輸入之前註冊的密碼')
# 登錄校驗-登錄成功 and
if username_login == usename_register and password_login == password_register:
print('登錄成功')
else:
print('登錄失敗')
# 登錄校驗-登錄失敗 (1.用戶名不對,密碼對 2.用戶名對,密碼不對 3.都不會)
# if (username_login != usename_register and password_login == password_register) or (username_login == usename_register and password_login != password_register) or (username_login != usename_register and password_login != password_register):
# print('用戶名/密碼有誤')
“”"
雙分支結構:
點數大小問題
三元條件表達式:
“”"
import random
n = random.randint(1, 6)
# if 1 <= n <= 3:
# result = '小'
# else:
# result = '大'
# 三元條件表達式
result = '小' if 1 <= n <= 3 else '大'
print(result)
“”"
分支結構:
1.單分支
if 條件:
條件成立執行的代碼
2.雙分支
if 條件:
條件成立執行的代碼
else:
條件不成立執行的代碼
3.多分支
if 條件1:
條件1滿足執行
elif 條件2:
條件2滿足執行
elif 條件3:
條件3滿足執行
…
else:
其他情況
需求:
根據你考試的分數,給出對應的評級
A:[90,100]
B:[80,90)
C:[70,80)
D:[60,70)
E: < 60
需求: 輸入一個月份,打印對應的季節
“”"
score = input(‘請輸入你考試的分數:’)
自動轉換
score = eval(score)
if 90 <= score <= 100:
print('A')
elif 80 <= score < 90:
print('B')
elif 70 <= score < 80:
print('C')
elif 60 <= score < 70:
print('D')
elif 0 <= score < 60:
print('E')
else:
print('分數有誤')
“”"
需求: 輸入一個月份,打印對應的季節
1.輸入 input()
2.類型轉換
3.多分支
春:
3-5
夏:
6-8
秋:
9-11
冬:
12,1,2
“”"
month = input('請輸入一個月份1-12:')
month = int(month)
if 3 <= month <= 5:
print('春天')
elif 6 <= month <= 8:
print('夏天')
elif 9 <= month <= 11:
print('秋天')
***# elif month == 12 or month == 1 or month == 2:***
elif month == 12 or 1 <= month <= 2:
print('冬天')
else:
print('輸入有誤')
“”"
分支的嵌套使用
if 外部條件:
外部條件成立
if 內部條件:
內部條件成立
else:
內部條件不成立
else:
外部條件不成立
生活案例:
if 有車票:
進站安檢
if 安檢合格:
可以進站候車
else:
安檢不合格無法進站
else:
無法進入安檢
開發過程中的使用:
“”"
“”"
骰子點數大小問題:
猜(輸入)
你猜的結果跟開獎的結果做比較,中還是沒中
1.先猜
2.搖點數
3.開獎
需求:
輸入用戶名密碼
if 用戶名密碼都正確:
直接打印出模擬生成驗證碼:
if 驗證碼是否正確:
登錄成功
else:
驗證碼有誤
else:
用戶名或密碼有誤
“”"
i
mport random
# 猜的點數
result_guess = input('請猜大/小:')
# 生成隨機點數
n = random.randint(1, 6)
# 比較處理
if result_guess == '大':
if 4 <= n <= 6:
print(f'恭喜中獎:猜的大,開的{n}')
else:
print('很遺憾,猜的大,開的小')
else:
if 4 <= n <= 6:
print('很遺憾,猜的小,開的大')
else:
print(f'恭喜中獎,猜的小,開的{n}')
“”"
需求:
輸入用戶名密碼
if 用戶名密碼都正確:
直接打印出模擬生成驗證碼:
if 驗證碼是否正確:
登錄成功
else:
驗證碼有誤
else:
用戶名或密碼有誤
“”"
import random
usename_register = 'abc'
password_register = '123'
# 驗證登錄
username_login = input('請輸入之前註冊的用戶名:')
password_login = input('請輸入之前註冊的密碼')
***if username_login == usename_register and password_login == password_register:***
# 接入短信接口,可以實現爲手機號發送短信
rand_code = random.randint(1000,9999)
rand_code = str(rand_code)
print(rand_code)
code_input = input('請輸入你接到到的驗證碼')
if rand_code == code_input:
print('登錄成功')
else:
print('驗證碼有誤')
else:
print('用戶名/密碼有誤')
“”"
1.順序結構
2.分支結構
3.循環結構
重複
while
語法:
while 條件:
條件成立執行(執行完畢之後,會繼續判斷條件)
死循環:
while True:
while 1 < 2:
執行
案例:
打印10次HelloWorld
練習:
打印1-100之間所有的偶數
for
“”"
# print('HelloWorld')
# print('HelloWorld')
# print('HelloWorld')
# i = 1
# while i <= 10:
# print(f'HelloWorld{i}')
# i = i + 1
想打印1-100之間的數字
# i = 1
# while i <= 100:
# print(i)
# i += 1
# i = 0
# while i <= 100:
# print(i)
# i += 2
打印10-1所有的數字
# i = 10
# while i >= 1:
# print(i)
# i -= 1
“”"
1.數據類型的轉換
自動轉換
由低到高自動轉換
bool->int->float->complex
強制轉換
不同的數值類型之間,由高到低,需要強制轉換
不同的數據類型之間,需要強制轉換
int()
float()
str()
bool()
---------
list()
set()
dict()
tuple()
----------
chr(code)
ord()
---------
eval()
1.根據字符串類型自動轉換對應的數值類型
2.將字符串表達式轉換爲實際表達式並進行運算,得出運算結果
2.輸出
print(‘xxx’)
格式化輸出:
%s
%i/%d
%f
%g
name = ‘xx’
age = 18
print(‘我叫%s,今年%i’%(name,age),end=’’)
print(f’我叫{name},今年{age}’)
print(f’我叫{“小明”}’)
3.輸入
v = input(‘輸入提示’)
不論輸入的是什麼內容,v都是以字符串的形式存在的
4.語句結構
順序結構
從上往下,從左往右依次執行
分支結構
判斷,選擇
單分支
if 條件:
條件成立執行
雙分支
if 條件:
條件成立執行
else:
條件不成立執行
多分支
if 條件1:
條件1成立執行
elif 條件2:
條件2成立執行
...
else:
除以上條件之外,會執行
循環結構
判斷,重複
while 條件:
條件成立執行
讓條件趨向終止
“”"
# v = input('請輸入一個整數或小數')
# print(type(v))
# print(v)
# print('---'*20)
# v = eval(v)
# print(type(v))
# print(v)
print(f'我叫{"小明"}')
“”"
1.輸入一個考試分數,判斷考試結果是否爲通過,如果分數>= 60,通過,
否則,結果爲不通過(分別使用雙分支,以及三元條件表達式)
“”"
# score = input('請輸入你的考試分數')
# score = eval(score)
# v = '通過'if score >= 60 else '不通過'
# print(v)
“”"
3.循環輸入5個100以內的正整數,打印出輸入的最大值,最小值,總和
“”"
max_value = 0
min_value = 100
sum = 0
i = 1
while i <= 5:
n = int(input(f'請輸入第{i}個100以內的整數'))
if n > max_value:
max_value = n
if n < min_value:
min_value = n
# 將輸入的數字累加到變量sum中
# sum = sum + n
sum += n
print(f'當前的最大值爲:{max_value}')
print(f'當前的最小值爲:{min_value}')
i += 1
print(f'最終的最大值爲:{max_value}')
print(f'最終的最小值爲:{min_value}')
print(f'所有數字的和爲:{sum}')
“”"
5.使用一個循環打印出所有的英文字母(大小寫)
A-Z
65-90
a-z
97-122
chr()
“”"
# i = 65
# while i <= 90:
# print(chr(i),end=' ')
# print(chr(i+32),end=' ')
# i += 1
“”"
6.打印以下數列 1/3 , 2/5 ,3/7 , 4/9…前10項,並求出總和
“”"
# i = 1
# while i <= 10:
# j = 2 * i + 1
# print(f'{i}/{j}',end=',')
# i += 1
# for i in range(10):
# j=2*i+1
# print(f'{i}/{j}',end=',')
“”"
7.使用循環如下圖形:
*
**
“”"
# for i in range(1,6):
# print('*'*i)
# i = 1
# while i <= 5:
# # * 可以實現字符串的重複
# print('*'*i)
# i += 1
# print('--'*20)
“”"
8.猜拳遊戲(玩10次):
while 終止條件:
cmp = 計算機隨機生成(0,2) #0.石頭 1.剪刀 2.布
you = 輸入(0.石頭 1.剪刀 2.布)
if 計算機獲勝的情況:
print(計算機得1分)
elif 平局:
print(‘平局’)
else:
print(‘你得1分’)
print(統計結果)
“”"
import random
# 記錄你贏的次數
a = 0
# 計算機贏的次數
b = 0
# 平局次數
c = 0
i = 1
while i <= 10:
cmp = random.randint(0,2)
you = int(input('計算機思考完畢,該你了:0-石頭 1-剪刀 2-布'))
# 比輸贏(1.從用戶的輸贏的角度來考慮 2.可以從用戶出的什麼角度來考慮)
***if (you == 0 and cmp == 1) or (you == 1 and cmp == 2) or (you == 2 and cmp == 0):***
print('you win!')
a += 1
elif you == cmp:
print('平局')
c += 1
else:
print('you lose!')
b += 1
i += 1
else:
# 與while循環結合使用的else 會在循環正常結束後執行
print(f'你獲勝{a}次,平局{c}次,輸了{b}次,勝率{a/10*100}%')
“”"
循環結構:
while循環
語法:
while 條件:
循環體
條件趨向終止
for循環
語法:
for 變量 in range():
循環體
range(stop)
range(start,stop,step)
start:表示起點,可以不寫,默認從0開始
stop:表示終點(但是不包含終點這個數)
step:表示的步長,默認爲1
循環控制的關鍵字
break:
結束當前循環
continue
跳過本次循環
for
pass
else
pass
“”"
打印1-5的整型數字
# i = 1
# while i <= 5:
# print(i,end=' ')
# i += 1
# for i in range(100,0,-22):
# if i>=36:
# continue
# if i==22:
# continue
# if i==8:
# break
# print(i,end='\t')
# for i in range(1,6,1):
# print(i,end=' ')
# 不寫步長,默認爲1
# for i in range(1,6):
# print(i,end=' ')
# 不寫起點,默認從0開始
# for i in range(6):
# print(i,end=' ')
# i = 5
# while i > 0:
# print(i,end=' ')
# i -= 1
# print(f'while循環已經結束,i={i}')
# list1=[111,2,3,4,555,3,2,121]
# list2=list1[-1:-3:-1]
# print(list2)
#
# print('-------------------------')
#
# for i in range(5,0,-1):
# print(i,end=' ')
# print(f'循環已經結束,i={i}')
使用for循環打印100以內的偶數
# for i in range(2,101,2):
# print(i,end=' ')
循環生成10以內的隨機數字,直到生成8結束(循環次數未知)
# import random
# n = 0
# i = 0
# while n != 8:
# n = random.randint(1,10)
# i += 1
# print(f'第{i}次生成的隨機數字爲{n}')
break 與 continue的使用
# for i in range(10):
# if i == 5:
# # break
# continue
# print(i,end=' ')
for-else的使用
# for i in range(10):
# if i == 5:
# break
# # if i == 9:
# # continue
# print(i,end=' ')
# else:
# print('循環正常結束')
# print('循環結束')
“”"
嵌套分支:
嵌套循環:
外循環
內循環
while
while
while
for
for
for
for
while
執行:
外循環執行一次,內循環從頭到尾執行一遍
“”"
# for i in range(5):
# print(f'外循環,i = {i}')
# for j in range(5):
# print(f'內循環,j = {j}')
# i = 0
# while i < 5:
# print(f'i = {i}')
# j = 0
# while j < 5:
# print(f'j={j}')
# j += 1
# i += 1
嵌套循環中的break
break 結束所在的循環
# end = False
# for i in range(5):
# print(f'外循環,i = {i}')
# if end:
# break
# for j in range(5):
# if j == 2:
# end = True
# break
# print(f'j = {j}')
# for i in range(1,11):
# if i%2==0:
# continue
# for j in range(11-i):
# if j%2==1:
# continue
# for k in range(2*i-1):
# print(i,end='\t')
# print()
***# for i in range(100,200,2):***
***# if i%3==0 and i%7!=0 or i%7==0 and i%3!=0:***
***# for j in range(200-i):***
***# continue***
***# print(i,end='\t')***
“”"
使用嵌套循環,打印矩陣時,外循環控制行,內循環控制列
**
“”"
# print('*****')
# print('*'*5)
# count1 = 5
# count0 = 6
# count1 = 8
# for j in range(count0):
# for i in range(count1):
# print('*', end=' ')
# else:
# print()
***# for i in range(1,10):
# # 每一行中的內容
# for j in range(i):
# print('? * ? = ?',end=' ')
# print()***
# for i in range(5):
# for j in range(i+1):
# print('*',end='')
# print()
# a=5
# b=6
***# for i in range(a):***
***# for j in range(b):***
***# if i==0 or j==b-1 or j==0 or i==a-1:***
***# print('*',end='\t')***
***# else:***
***# print('',end='\t')***
# print()
# a=5
# for i in range(a):
# for j in range(a-i):
# print('*',end='\t')
# print()
#運行後
*****
****
***
**
*
打印菱形
# *
# ***
# *****
# *******
# *********
# *******
# *****
# ***
# *
for i in range(1,5):
for j in range(5-i):
print(’ ‘,end=’’)
for k in range(2*i-1):
print(’*’,end=’’)
print()
for i in range(5,0,-1):
for j in range(5-i):
print(’ ‘,end=’’)
for k in range(2*i-1):
print(’*’,end=’’)
print()
for i in range(1,4):
for j in range(4-i):
print(’ ‘,end=’’)
for k in range(2i-1):
print(’’,end=’’)
print()
for i in range(4,0,-1):
for j in range(4-i):
print(’ ‘,end=’’)
for k in range(2i-1):
print(’’,end=’’)
print()
# for i in range(1,10):
# # 每一行中的內容
# for j in range(i):
*# print(f’{j+1} * {i} = {(j+1)i}’,end=’\t’)
# print()
“”"
打印空心矩陣
-
*
-
*
-
*
-
*
打印等腰三角形
*
“”"
count0 = 10
count1 = 15
for j in range(count0):
for i in range(count1):
# 如果是第一行或者最後一行第一列或者最後一列 j控制行 i控制列
# if j == 0 or j == count0-1 or i == 0 or i == count1-1:
print(’*’, end=’ ')
else:
print(’ ‘,end=’ ')
else:
print()
打印等腰三角形
for i in range(1,5):
# 打印‘ ’
for k in range(5-i):
print(’ ‘,end=’’)
# 打印*
for j in range(2*i-1):
print(’*’,end=’’)
print()
“”"
練習 打印1-100之間所有數字,按指定的要求的分行
分行示例如下:
1
2 3
4 5 6
7 8 9 10
…
“”"
# 用來幾個數字進行換行
count = 1
# 計數器
count2 = 0
for i in range(1,101):
print(i,end=’\t’)
count2 += 1
if count2 == count:
print()
# 每換行一次,控制換行的個數+1
count += 1
# 計數器清0,保證下次從頭開始數
count2 = 0
a=1
a1=0
for i in range(2,101,2):
print(i,end=’\t’)
a1+=1
if a1==a:
print()
a+=1
a1=0
a2=1
a3=0
for i in range(100,0,-1):
print(i,end=’\t’)
a3+=1
if a3==a2:
print()
a2+=1
a3=0
“”"
列表(list)
可以存儲多個任意類型的數據
引入
存儲某個學生的信息
名字 年齡 性別
定義
stu_info = []
內存結構
棧上存地址
堆上存數據
求列表長度(列表中元素的個數)
len(list)
列表特點:
可以重複,有序
索引問題
可以訪問列表中的具體元素
list[index]
注意:
索引越界問題
IndexError
索引範圍:
【0,len(list)-1】
序列操作
相加
重複
切片
遍歷
序列解包
多個變量名來接收元素
“”"
定義
stu0_info = [‘王鐵錘’,18,‘女’,170,98]
通過系統提供的功能添加元素
stu0_info.append(1001)
print(type(stu0_info))
print(f’列表stu0_info的內存地址爲:{id(stu0_info)}’)
stu1_info = stu0_info
print(f’列表stu1_info的內存地址爲:{id(stu1_info)}’)
print(f’名稱:{stu0_info[0]}’)
IndexError: list index out of range
print(stu0_info[5])
stu1_info[2] = ‘男’
print(stu1_info)
print(stu0_info)
list1 = [1,2]
list2 = [2,3]
list3 = list1 + list2
print(list3)
可以通過* 完成列表的重複創建
list4 = list1 * 2
print(list4)
print(’–’*30)
列表中元素的遍歷(打印列表中所有的元素)
i = 0
while i < len(stu0_info):
print(stu0_info[i])
i += 1
for i in range(len(stu0_info)):
print(stu0_info[i])
for 變量 in 列表:
for i in stu0_info:
print(i)
“”"
1.for循環
for 變量 in range():
pass
range(stop)
range(start,stop,step)
start: 表示開始
默認爲0
stop: 表示結束
step: 表示步長
默認步長爲1
步長可以爲負數,表示遞減
for
else:
循環正常結束會執行的代碼
break:
結束當前循環
continue:
表示跳過本次循環
2.嵌套循環
外循環
內循環
執行順序:
外循環執行一次,內循環從頭到尾執行一遍
3.列表的基本使用
list
概念:
可以存儲任意多個不同類型的數據
定義:
list1 = []
特點:
有序,元素可以重複
內存:
兩塊內存,棧上存地址(引用),堆上存數據
長度:
len(list)
訪問元素:
通過索引值
list[index]
索引範圍
[0,len(list)-1]
拼接:
v = [1,2]+[3,4]
重複:
v = [1,2]*2
尾部添加:
list.append(e)
“”"
l0 = [1,1,1,4,5,6,7]
l = [1,2,3,4,5,6,7]
for i in range(len(l)-3):
l1 = l[i:i+4]
if l1 == l0[i:i+4]:
print(f’中出號碼爲{l1}’)
break
print(l1)
“”"
1.從鍵盤錄入行爲5,列爲5,打印如下圖形:
-
*
-
*
-
*
“”"
a = int(input(‘請輸入行’))
b = int(input(‘請輸入列’))
for i in range(a):
for j in range(b):
# if i == 0 or i == a-1 or j == 0 or j == b-1:
print(’*’,end=’ ')
else:
print(’ ‘,end=’ ')
print()
“”"
2.循環生成10個100以內的隨機數,存儲到列表中,找出最大值,最小值
“”"
import random
# 定義一個列表,用來存儲所有的數據
nums_list = []
for i in range(10):
n = random.randint(1,100)
nums_list.append(n)
print(’–’*20)
print(nums_list)
假設列表中的最大值爲第一個元素
max_value = nums_list[0]
# 假設列表中的最小值爲第一個元素
min_value = nums_list[0]
循環將當前最大值與其他數據一次比較,找出最大的,最小的
for i in range(1,len(nums_list)):
if max_value < nums_list[i]:
max_value = nums_list[i]
if min_value > nums_list[i]:
min_value = nums_list[i]
調用系統功能直接實現:
max_value = max(nums_list)
min_value = min(nums_list)
print(f’{nums_list}中最大值爲:{max_value} 最小值爲:{min_value}’)
“”"
3.生成一個長度爲4的驗證碼,存儲到列表中,要求前兩個爲小寫字母,後兩個爲0-9之間的數字
“”"
import random
code_list = []
for i in range(4):
if i < 2:
# 生成對應的隨機數,使用chr轉換爲字母
code = chr(random.randint(97,122))
code_list.append(code)
else:
n = str(random.randint(0,9))
code_list.append(n)
print(code_list)
“”"
斐波那契數列
4.有一個數列(例如:1,1,2,3,5,8,13…),使用循環求出數列的第n個數,n爲從鍵盤錄入的
“”"
n = int(input(‘請輸入要求的第幾個數’))
使用循環實現
a = 1
b = 1
i = 3
while i <= n:
a, b = b, a + b
print(b,end=’\t’)
i += 1
使用列表實現
list1 = [1,1]
i = 3
while i <= n:
list1.append(list1[-2]+list1[-1])
i += 1
print(list1[n-1])
import sys
print(sys.getsizeof(list1))
“”"
5.從鍵盤錄入一個數字,找出這個數字的所有約數,存儲到列表中
約束: 能被整除的數
“”"
nums_list = []
n = int(input(‘請輸入一個數字’))
for i in range(1,n+1):
# 判斷n是否能被i整除
if n % i == 0:
nums_list.append(i)
print(nums_list)
“”"
6.錄入兩個數字,找出兩個數字的最大公約數
“”"
a = int(input(‘請輸入一個整數’))
b = int(input(‘請輸入另外一個整數’))
存儲a的所有約數
nums_list1 = []
存儲b的所有約數
nums_list2 = []
求出a的所有約數
for i in range(1,a+1):
if a % i == 0:
nums_list1.append(i)
求出b的所有約數
for i in range(1,b+1):
if b % i == 0:
nums_list2.append(i)
print(nums_list1)
print(nums_list2)
遍歷其中一個列表的數據(從後往前進行遍歷)
for i in range(len(nums_list1)-1,-1,-1):
# 如果這個約數在另外一個列表
if nums_list1[i] in nums_list2:
print(f’最大公約數:{nums_list1[i]}’)
# 找到之後直接結束
break
“”"
7.模擬隨機生成一組福利彩票10選3的號碼(不能有重號)
1-10的號碼選3個數
“”"
import random
nums_list = []
while len(nums_list) < 3:
n = random.randint(1,10)
if n not in nums_list:
nums_list.append(n)
print(nums_list)
“”"
8.手動選擇一組號碼,存儲到列表中(不能有重號,如果輸入的爲重號,則提示重新輸入)
“”"
nums_list1 = []
while len(nums_list1) < 3:
n = int(input(‘請輸入1-10之間的任意數字’))
if n not in nums_list1:
nums_list1.append(n)
else:
print(‘號碼重複,重新輸入’)
else:
print(f’你輸入的號碼爲:{nums_list1}’)
“”"
9.統計出兩組號碼(手選號碼與隨機號碼)中的相同號碼,存儲到新列表中
“”"
遍歷其中一個列表,看這個列表中的元素是否在另外一個列表中,如果在,添加到新列表中
nums_list2 = []
for n in nums_list:
if n in nums_list1:
nums_list2.append(n)
使用嵌套循環 找出兩個列表中相同的元素
nums_list2 = []
for n in nums_list:
for m in nums_list1:
if n == m:
nums_list2.append(n)
break
print(f’相同號碼爲:{nums_list2}’)
“”"
列表的切片:
意義:
可以基於一個列表,通過切片操作,得到一個新的列表
注意:
基於索引值操作
語法:
list[start:stop:step]
start:
表示切片的開始位置
可以省略不寫,如果不寫,默認從頭開始
stop:
表示切片的結束位置(不包含終點)
可以省略不寫,如果不寫,默認到最後(包含最後一個)
step:
步長
可以省略,如果不寫,默認值爲1
“”"
char_list = [‘a’,‘b’,‘c’,‘d’,‘e’,‘f’,‘g’]
切片出前三個
sub_list1 = char_list[0:3]
sub_list1 = char_list[0:3:1]
sub_list1 = char_list[:3]
print(type(sub_list1))
print(sub_list1)
切出最後三個
sub_list2 = char_list[4:6]
切片操作中,不存在越界問題
sub_list2 = char_list[4:7]
sub_list2 = char_list[4:700]
sub_list2 = char_list[4:]
sub_list2 = char_list[len(char_list)-3:]
print(char_list[-3:])
print(sub_list2)
print(’—’*20)
步長的問題
sub_list3 = char_list[0::]
sub_list3 = char_list[::2]
print(sub_list3)
print(’----’*20)
步長爲負數的問題:
sub_list4 = char_list[3:0:-1]# a b c d e f g
print(sub_list4)
快速得到一個倒序的列表
sub_list5 = char_list[::-1]
print(sub_list5)
“”"
操作列表的常用功能
添加元素
append(obj)
尾部條件元素
insert(index,obj)
指定位置插入指定元素
待驗證效率問題
extend(list)
將一個列表中的所有元素,逐個加入到列表一個列表
刪除元素
list.remove(要刪除的元素)
del list[index]
list.pop(index)
list.clear()
查詢元素
修改元素
“”"
list1 = [1,2]
list1.append(3)
print(list1)
list1.insert(0,4)
print(list1)
list2 = [7,8]
將列表2中的所有元素追加到列表1中
list1.extend(list2)
print(list1)#[4, 1, 2, 3, 7, 8]
基於兩個列表中的數據,創建一個新的列表
list3 = list1 + list2
list1.remove(8)
print(list1)# [4, 1, 2, 3, 7]
list1.pop(0)
print(list1)# [1, 2, 3, 7]
del list1[0]
print(list1)# [ 2, 3, 7]
list1.clear()
print(list1)# []
“”"
查詢
value in list
列表是否包含目標元素
value not in list
列表中是否不包含目標元素
index(obj)
查看目標元素在列表中首次出現的索引值,如果沒有,報錯
count(obj)
查看目標元素出現的次數
修改
賦值:
list[index] = value
翻轉:
list.reverse()
將列表翻轉(對源數據操作)
reversed(list)
得到一個翻轉的新列表
排序:
list.sort()
按自然順序(對源數據排序)
list.sort(reverse=True)
按從大到小順序排序
sorted(list)
按自然順序排序(得到一個排序後的新列表,源數據不變)
“”"
查找操作
list1 = [1,2,3,4,3,3,3,3]
v = 1 in list1
# v = 1 not in list1
print(v)
i = list1.index(3)
# i = list1.index(100)# ValueError: 100 is not in list
print(i)
# j = list1.count(3)
j = list1.count(100)
print(j)
修改操作
list1 = [1,10,2,4,3,0]
list1[0] = 100
將元素1修改爲100(1、是否有該元素 2、找索引 3、按索引修改)
if 1 in list1:
i = list1.index(1)
list1[i] = 100
翻轉
list1.reverse()
print(list1)
list2 = reversed(list1)
print(list1)
for i in list2:
print(i)
排序
list1.sort(reverse=True)# 對源數據進行排序
print(list1)
得到一個排序後新列表,源數據不變
list2 = sorted(list1)
print(list1)
print(list2)
“”"
嵌套列表
可以存儲任意多個不同數據類型的集合(有序序列)
# 使用列表存儲一個學生的信息
stu = [‘xxx’,18,‘男’]
students = [[‘xxx’,18,‘男’],[‘xxx’,18,‘女’],[‘xxx’,18,‘男’]]
嵌套列表中元素的訪問:
list1[][]
嵌套列表的內存結構:
list1 = [[1,2],[3,4]]
需求:
使用列表存儲從鍵盤錄入的3個學生,(每個學生包含:姓名,年齡)
“”"
存儲3個學生信息
students = [[‘aaa’,12],[‘bbb’,18],[‘ccc’,38]]
訪問第二個學生的名字
print(students[1][0])
for i in range(1,4):
print(f’請輸入第{i}個學生的信息’)
name = input(‘姓名:’)
age = input(‘年齡:’)
stu = [name,age]
students.append(stu)
print(students)
遍歷列表中每一個元素
for i in range(len(students)):
stu_list = students[i]
for e in stu_list:
print(e,end=’ ')
print()
“”"
深淺複製:
列表中自帶的功能是淺複製
import copy
copy模塊中提供了深淺複製功能
淺複製
copy.copy(x)
深複製
copy.deepcopy(x)
區別:
1.如果列表存儲的數據爲基本類型,深淺複製沒有區別,都是複製一份新的出來
2.如果列表中存儲的數據爲複合對象(列表中存儲的元素爲列表,字典,元組…),深淺複製有區別
2.1 淺複製
儘可能複製地址
2.2 深複製
儘可能複製數據
“”"
import copy
list1 = [1,2]
list2 = [3,4]
list3 = [list1,list2]
# 調用列表的複製功能
list4 = list1.copy()
print(id(list1))
print(id(list4))
list4[0] = 100
print(list1)
print(list4)
淺複製一份list3
list5 = copy.copy(list3)
list5 = copy.deepcopy(list3)
通過索引修改值
list5[0][0] = 100
print(list3[0][0])
“”"
列表:
1.列表的切片
list[start:stop:step]
索引值爲負值的時候,表示的倒數第幾個數
start: 表示索引開始位置
省略不寫,默認從0開始
stop:表示結束的索引位置(不包含該位置)
省略不寫,默認到最後位置(包含最後一個的)
step:表示步長
不寫的情況下,默認值爲1
可以爲負值
實現列表的反轉:
list[::-1]
2.列表的增刪查改
增加:
append(obj)
尾部添加元素
insert(index,obj)
在指定位置插入執行的元素
extend(list)
可以將另外一個列表中的元素,逐個添加到當前列表中
刪除:
可以根據值刪、可以根據索引值刪
remove(obj)
pop(index)
del list[index]
clear()
查詢:
查詢是否包含、查詢所在的位置(索引值)
obj in list
not in
count(obj)
index(obj)
得到obj在列表中所在索引值,如果列表中不包含,直接報錯
修改:
list[index] = new_value
排序:
list.sort()# 從小到大
list.sort(reverse=True)# 從大到小
sorted(list)
基於源數據(不變)內容,得到一個新的列表(排序後的)
翻轉:
list.reverse()
reversed(list)
基於源數據內容(不變),得到一個新的反轉後的列表
3.嵌套列表的定義以及使用
列表中的元素,同樣也是列表
list1 = [[[10,100],2],[3,4]]
內存:
必須能畫出來
嵌套列表中元素的訪問:
list[][][]
list1[0][1]
4.列表的複製操作
list.copy()
深淺複製:
import copy
copy.copy() 淺複製
copy.deepcopy() 深複製
二者區別與聯繫:
對於一般數據,二者同樣都是實現複製一份新的出來
區別:
列表中如果存儲的數據爲複合對象,
淺複製:儘可能的複製引用(地址)
深複製:遞歸複製所有元素的內容
“”"
list1 = [1,2,3]
list2 = list1
list3 = list1.copy()
hex(地址)
print(hex(id(list1)))
print(hex(id(list2)))
print(hex(id(list3)))
list2 與 list3
“”"
2.循環錄入3個學生的學生信息(姓名,年齡,性別,分數),
存儲到合理的序列中(使用嵌套列表)
“”"
students = []
count = 3
for i in range(1,count + 1):
print(f’請輸入第{i}個學生的信息’)
name = input(‘姓名:’)
age = eval(input(‘年齡:’))
gender = input(‘性別:’)
score = eval(input(‘分數:’))
stu = [name,age,gender,score]
students.append(stu)
print(students)
import time
start_time = time.time()
nums = []
for i in range(100000):
# nums.append(i)
nums.insert(0,i)
end_time = time.time()
print(f’耗時:{end_time-start_time}秒’)
“”"
3.生成一個包含n個(n從系統錄入)英文字母(大小均可)的列表,通過對位交換的方式實現列表的反轉
“”"
import random
chars = []
n = int(input(‘請輸入一個正整數:’))
for i in range(n):
chars.append(chr(random.randint(65,90)))
print(chars)
print(’-----’*20)
需要交換的次數
count = n // 2
for i in range(count):
chars[i],chars[len(chars)-1-i] = chars[len(chars)-1-i],chars[i]
print(chars)
import random
l1 = [1,2,3,4,5,6,7]
l2 = [1,0,3,4,5,6,0]
for i in range(0,7):
sub_list = l2[i:i+6]
if sub_list == l1[i:i+6]:
print(‘二等獎’)
break
if len(sub_list) < 6:
break
print(sub_list)
for i in range(0,7):
sub_list = l2[i:i+4]
if sub_list == l1[i:i+4]:
print(f’四等獎,中出號碼:{sub_list}’)
break
if len(sub_list) < 4:
break
“”"
list
list = []
tuple:
概念:
可以存儲任意多個不同類型數據的有序集合
特點:
不可變,有序,不唯一
特性操作:
定義:
t = ()
如果存儲元素,必須有’,‘
連接
+
重複
*
索引範圍
[0,len(t)-1]
訪問:
t[index]
存在越界問題
操作:
增加(不支持)
刪除(不支持)
查詢:
index()
count()
in
not in
修改(不支持)
遍歷:
for in
for in range()
while i < len():
t = 1,2,3
這時候t默認爲元組類型
dict
set
“”"
t = (1,)
print(type(t))
t2 = (2,)
t3 = t+t2
print(t3)
t4 = t3*2
print(t4)
print(t4[-1])
# print(t4[10]) #IndexError: tuple index out of range
t5 = ()
t5 = (1,2,3)
# del t5[0] # TypeError: ‘tuple’ object doesn’t support item deletion
print(t5)
i = t5.index(2)
print(i)
c = t5.count(2)
print©
print(1 in t5)
t5[0] = 100 # TypeError: ‘tuple’ object does not support item assignment
a, *b = 1, 2, 3
*a, b = 1, 2
print(type(a))
print(a)
print(type(b))
print(b)
print(’—’*20)
# t6 = 1, 2, 3
t6 = 1, 2, 3
print(type(t6))
print(t6)
元組的嵌套
t = ((1,2),(3,4))
t = ([1,2],[3,4])
t = [(1,2),(3,4)]
print(t[0][1])
t6 = (1,2)
基於元組的內容,創建一個新的列表
list1 = list(t6)
print(type(list1))
基於列表的內容創建元組
t7 = tuple(list1)
print(type(t7))
“”"
複合:
list
[]
tuple -> 不可變
()
---------
dict:
字典
映射關係
特點:
對於字典而言,沒有索引值,沒有默認順序(無序的,Python2 完全無序, Python3.5之後添加順序)
Python2之所以存儲的數據是無序,取決於底層的數據結構
哈希表(哈希表存儲數據的原理)
key唯一(值以後添加的爲準)
什麼類型可以做key?
一般情況下,建議使用字符串做key
不可變類型都可以做key
基本類型都爲不可變類型,tuple
不可變類型 (可以做key)
bool,int,float,str,tuple
可變類型(不能做key)
list,dict,set
作用:
存數據,可以多個數據
定義:
d = {}
存儲數據方式:(key:value) 鍵值對的存儲方式
stu_dict = {‘name’:‘xxx’,‘age’:18,‘gender’:‘男’}
訪問方式:
d[key]
set
“”"
# 定義一個空字典
d = {}
print(type(d))
# stu_list = [1001,‘xxx’,18,‘男’]
# print(f’姓名:{stu_list[0]} 年齡:{stu_list[1]} 性別:{stu_list[2]}’)
# 定義一個存儲3個減值對元素的字典
stu_dict = {‘id’:1001,‘name’:‘xxx’,‘age’:18,‘gender’:‘男’,‘id’:1002}
print(stu_dict)
# print(f’姓名:{stu_dict[0]} 年齡:{stu_dict[1]} 性別:{stu_dict[2]}’)
# 字典中元素的訪問,通過key獲取對應的值
print(f’學號:{stu_dict[“id”]} 姓名:{stu_dict[“name”]} 年齡:{stu_dict[“age”]} 性別:{stu_dict[“gender”]}’)
# d1 = {65:‘A’,66:‘B’,True:1,3.5:‘PI’,[1,2]:1}
d1 = {65:‘A’,66:‘B’,True:1,3.5:‘PI’,(1,2):1}
print(d1)
# 可變類型數據無法求hash值
#v = hash([1,2,3])
a={‘e’:8,‘o’:9,‘k’:0,‘m’:22,‘b’:88}
“”"
元素的訪問:
d[key]
訪問的時候,如果沒有指定key,則導致keyError
d.get()
訪問的時候,如果沒有自定key,不會報錯,會得到一個None
增:
d[key] = value
setdefault()
update(key=value)
刪:
pop()
popitem()隨機刪除
del
clear
查:
默認情況只能查key
in
not in
改:
d[key] = value
update(key=value)
country.update(IN=‘Indian’,JP=‘123’)
遍歷:
keys():
獲取字典中所有的key
python2 list
python3 生成器對象
values()
獲取字典中所有的value
items()
獲取字典中所有的鍵值對
“”"
country = {‘CN’:‘China’,‘JP’:‘Japan’}
print(country[‘CN’])
KeyError: ‘CH’
print(country[‘CH’])
print(country.get(‘CN’))
print(country.get(‘CH’))
# 首次出現該Key,添加
country[‘EN’] = ‘England’
後續出現該key,修改
country[‘EN’] = ‘America’
# country.setdefault(‘EN’,‘England’)
country.update(IN=‘Indian’,JP=‘123’)
print(country)
# 刪除
# v = country.pop(‘IN’)
# print(v)
# # 任意刪除一個
country.popitem()
print(country)
del country[‘CN’]
# country.clear()
print(country)
# 查詢
print(‘China’ in country)
print(‘CN’ in country)
# 字典的遍歷
for k in country:
print(f’國家簡稱:{k},國家全稱:{country[k]}’)
for k in country.keys():
print(f’國家簡稱:{k},國家全稱:{country[k]}’)
all_key = country.keys()
print(type(all_key))
print(all_key)
# 將dict_keys類型轉換爲列表類型
all_key_list = list(all_key)
print(all_key_list)
all_value = country.values()
print(all_value)
#
for value in country.values():
print(value)
print(’–’*20)
all_item = country.items()
print(all_item)
for i in country.items():
print(i)
for k,v in country.items():
# print(i)
print(k,v)
“”"
集合:Set
定義方式:
s = {}
特點:
無序,唯一
可以存儲什麼類型的數據?
只能存儲不可變類型的數據(等同於字典的key)
集合底層數據結構:
哈希表(添加,刪除,查找效率都很高)
存儲原理
長度:
len(s)
注意:
集合中沒有索引值
遍歷:
for in
增
add(elem)
刪
remove(elem)
pop()
discard(elem)
clear()
查
in
not in
改s
間接修改(刪舊的,添加新的)
使用場景:
快速去重
set(list)
list()
“”"
s = {‘1’,‘a’,10,0,‘x’,1,‘1’,(1,2)}
s = {‘1’,‘a’,10,0,‘x’,1,‘1’,(1,2),[1,2]}
s = {‘1’,‘a’,10,0,‘x’,1,‘1’,(1,2),{‘a’:1,‘b’:2}}
s = set()
print(type(s))
print(s)
v = hash(‘1’)
print(v)# 1193136600182093950, 457057545219557140,7439736106587348287
print(s[0]) # TypeError: ‘set’ object does not support indexing
for i in s:
print(i)
s1 = set()
s1.add(‘a’)
s1.add(‘z’)
s1.add(‘d’)
s1.add(‘f’)
s1.add(1)
print(s1)
刪除
s1.remove()
print(s1)
s1.pop()
print(s1)
s1.discard(1)
print(s1)
# list1 = [1,1,2,2,3,4,4]
# 去重列表中重複數據
# s = set(list1)
# print(s)
# 取交集,取反交集,取並集
set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}
# 取交集
set3 = set1 & set2
print(set3)
# 取反交集
set4 = set1 ^ set2
print(set4)
# 取並集
set5 = set1 | set2
print(set5)
“”"
字符串常用方法:
查找:
find
rfind
找不到,返回-1
----------
index
rindex
找不到,拋出異常
----------
count
統計出現次數,如果沒有,得到0
拆分
split
按指定的子串,將目標字符串拆分成列表
partition
拆分成 前,中,後三個組分的元組
rpartition
轉換
lower()
upper()
replace(old,new,count)
swapcase()
判斷
isdigit()
判斷純數字
isalnum()
判斷數字跟字母
isalpha()
純字母
isupper()
判斷大寫
islower()
判斷小寫
推導式
列表推導式
lst = [表達式 for if for]
字典推導式
d1 = {表達式 for if for}
集合推導式
s1 = {同列表推導式}
# 唯一,無序
面試試題:
- def func(lst=[])
內部保留lst之前的值 - lst = [lambda x :x + i for i in range(10)]
lst0
“”"
s1 = ‘abc123’
print(s1.split(’ ‘))
print(s1.partition(’ '))
lst = [lambda x :x + i for i in range(10)]
print(lst0)
print(lst1)
print(lst2)
def split_custom(src,sub):# 晚自習繼續
lst = []
start = 0
end = 0
for i in range(len(src)):
if sub == src[i:i+len(sub)]:
end = i
lst.append(src[start:end])
print(src[start:end])
start = end+len(sub)
lst.append(src[start:])
return lst
print(split_custom(‘a,b,cd,’,’,c’))
“”"
基礎練習題
1.封裝自定義函數,功能類似lower(src)
2.封裝自定義函數,功能類似upper(src)
3.封裝函數,功能類似find(src,sub)
4.封裝函數,功能類似rfind(src,sub)
5.封裝函數,功能類似isdigit(src)
6.封裝函數,功能類似partition(src,sub)
7.封裝函數,功能類似split(src,sub)
能力提升
1.封裝函數,功能類似startswith(src,sub)判斷字符串src是否以字符串sub的內容開頭
2.封裝函數,功能類似endswith(src,sub)判斷字符串src是否以字符串sub的內容結尾
“”"
#1.封裝自定義函數,功能類似lower(src)
def lower_custom(src):
s = ‘’
for ch in src:
if ‘A’ <= ch <= ‘Z’:
# 轉小寫
ch = chr(ord(ch)+32)
s += ch
return s
print(lower_custom(‘aBC123D’))
2.封裝自定義函數,功能類似upper(src)
def upper_custom(src):
s = ‘’
for ch in src:
if ‘a’ <= ch <= ‘z’:
# 轉大寫
ch = chr(ord(ch) - 32)
s += ch
return s
print(upper_custom(‘aBC123D’))
3.封裝函數,功能類似find(src,sub)
def find_custom(src,sub):
for i in range(len(src)):
if src[i:i+len(sub)] == sub:
return i
return -1
print(find_custom(‘abcd123’,‘d1’))
print(find_custom(‘abcd123’,‘1d’))
4.封裝函數,功能類似rfind(src,sub)
def rfind_custom(src,sub):
for i in range(len(src)-1,-1,-1):
if src[i:i+len(sub)] == sub:
return i
return -1
rfind_custom(‘abc123c10’,‘c1’)
“”"
5.封裝函數,功能類似isdigit(src)
6.封裝函數,功能類似partition(src,sub)
7.封裝函數,功能類似split(src,sub)
能力提升
1.封裝函數,功能類似startswith(src,sub)判斷字符串src是否以字符串sub的內容開頭
2.封裝函數,功能類似endswith(src,sub)判斷字符串src是否以字符串sub的內容結尾
“”"
5.封裝函數,功能類似isdigit(src)
def isdigit_custom(src):
for ch in src:
if not ‘0’ <= ch <= ‘9’:
return False
return True
print(isdigit_custom(‘123a’))
print(isdigit_custom(‘123’))
6.封裝函數,功能類似partition(src,sub)
import demo02_作業講解1
def partition_custom(src, sub): # abc123 c1 -> 2 src[:2]
if sub in src:
# 1 查找索引值
i = demo02_作業講解1.find_custom(src, sub)
# 2 根據索引值切片操作
# 3 返回元組
return (src[:i], sub, src[i + len(sub):])
else:
return (src, ‘’, ‘’)
print(partition_custom(‘abc123c145’,‘c1’))
print(partition_custom(‘abc123’,‘c3’))
7.封裝函數,功能類似split(src,sub)
def split_custom(src, sub): # 晚自習繼續
pass
1.封裝函數,功能類似startswith(src,sub)判斷字符串src是否以字符串sub的內容開頭
def startswith_custom(src, sub, start=None, stop=None):
if start == None and stop == None:
return sub == src[0:len(sub)]
else:
src = src[start:stop]
return sub == src[0:len(sub)]
print(startswith_custom(‘abc123’,‘abc1’))
print(startswith_custom(‘abc123’,‘babc1’))
print(startswith_custom(‘abc123’,‘abc1’,1,5))
2.封裝函數,功能類似endswith(src,sub)判斷字符串src是否以字符串sub的內容結尾
def endswith_custom(src, sub):
# return sub == src[len(src)-len(sub):]
return sub == src[-len(sub):]
print(endswith_custom(‘abc123’, ‘123’))
print(endswith_custom(‘abc123’, ‘1234’))
“”"
-
什麼是模塊?
一個.py文件就被稱爲一個模塊
2.模塊的分類
2.1 內置模塊
2.2 系統標準模塊
random
time
sys
2.3 第三方模塊
pygame2.4 自定義模塊
-
模塊中的內容(可以寫任意內容)
變量
函數
可執行的代碼
4.封裝一個自定義模塊(求圓的面積,求圓的周長)
5.模塊的使用
5.1 引入模塊
import 模塊1,模塊2
import 模塊名 as 新名字
import 模塊1名 as 新名字1,模塊2名 as 新名字2
引入之後,功能的使用
模塊名/新名.變量/函數
import random
random.randint(a,b)
注意:
1.import 模塊時, 模塊中的內容會被加載到系統內存(會執行一遍)
2.無論被引入多少次,只加載一次
5.2 引入模塊中的部分功能
from 模塊 import 功能(變量,函數)
from 模塊 import 功能(變量,函數) as 新功能名
from 模塊 import 功能1,功能2,功能3(變量,函數)
from 模塊 import *
默認引入所有,如果有__all__ = [],只引入列表中包含的
使用方式:
直接使用,不用帶模塊名
功能()
注意:
只有手動引入的,可以使用,其他的無法使用
“”"
import circle
r = eval(input(‘輸入圓的半徑:’))
s = circle.get_area®
print(f’半徑爲:{r}的圓的面積爲:{s}’)
import circle as c
import circle as c
import circle as c
r = eval(input(‘輸入圓的半徑:’))
s = c.get_area®
print(f’半徑爲:{r}的圓的面積爲:{s}’)
from circle import PI,get_area as ga
print(PI)
# s = get_area(2)
s = ga(2)
print(s)
*
from circle import *
print(PI)
s = get_area(2)
# l = get_perimeter(2)
“”"
包: package
python2
文件夾(必須包含一個名稱爲__init__.py的模塊)
python3
文件夾
包的用途:
1.整理作用
2.不同的包中,可以存在同名模塊
存儲在包中的模塊如何引用:
import 包名.模塊名
使用
包名.模塊名.功能
from 包名.模塊名... import 變量名
from 包名.模塊名... import 變量名 1,變量名 2...
from 包名 import 模塊名
from 包名 import 模塊名,模塊名 1...
“”"
import package1.circle
print(package1.circle.PI)
import package1.circle as a
print(a.PI)
from package2.module1 import PI
print(PI)
從包中引入模塊
from package1 import circle
print(circle.PI)
“”"
面向對象:
封裝
繼承
多態
面向過程與面向對象
面向過程:
1.
2.
3.
面向對象:
對象
如何把大象裝進冰箱裏:
面向過程:
1.打開冰箱門
2.將大象裝進去
3.關上冰箱門
面向對象:
找個人(對象)
開車:
面向過程的思想:
1.系安全帶
2.踩離合
3.打火
4.鬆手剎
5.掛擋
6.松離合/給油
面向對象:
找個司機(對象)
喫個蛋炒飯
面向過程:
1.先蒸米飯
2.炒雞蛋
3.炒米
4.出鍋
面向對象:
找個飯館(廚師)
“”"
“”"
面向對象:
類(抽象的,整體,模板)
對象(具體的東西,人,個體,具體的實物)
先有類,基於類可以創建出任意多個的對象
類中存儲共性的東西
所有對象都是基於類的模板創建出來的
奧迪汽車 類
張三停在車庫的奧迪A8 對象
雅迪 類
人 類
咱班坐在xx的xx 對象
筆記本 類
thinkPad 類
小明的thinkPad 對象
“”"
"""
面向對象:
類(抽象的,整體,模板)
對象(具體的東西,人,個體,具體的實物)
先有類,基於類可以創建出任意多個的對象
類中存儲共性的東西
所有對象都是基於類的模板創建出來的
奧迪汽車 類
張三停在車庫的奧迪A8 對象
雅迪 類
人 類
咱班坐在xx的xx 對象
筆記本 類
thinkPad 類
小明的thinkPad 對象
"""
"""
自定義一個類
class 類名:
pass
駕駛員類:
屬性:
行爲:
函數/方法
開車
創建對象的語法:
變量(對象)名 = 類名()
調用方法語法:
對象名.方法名(實參)
"""
# 自定義類
class Driver:
# 行爲: 自定義一個方法
def drive_car(self):
print('1.踩離合')
print('2.打火')
print('3.掛擋')
print('4.松離合/給油')
print('嘀嘀嘀,走起~~~')
# 創建一個對象
d = Driver()
# 通過對象,調用對象的功能
d.drive_car()
# 創建一個字符串對象
s = 'abc123'
i = s.find('c1')
# l = [1,2,0,-3]
# l.sort()
"""
面向對象:
面向過程
注重步驟與算法
面向對象
對象
類與對象
類(模板,先封裝類)
對象(基於模板創建的實例)
類的分類:
系統類
自定義類
類的組成:
屬性:
行爲:
創建類的語法:
class 類名(object):
經典類(舊式類)
class 類名:
pass
新式類:
class 類名(object):
pass
基於類創建對象:
對象名 = 類名()
調用對象方法:
對象名.方法名(參數...)
"""
# 封裝一個學生類
class Student:
def study(self):
print('我愛學習,一天不寫代碼,難受~~~')
def eat(self):
print('我愛喫,一天不喫,難受~~~~')
# 創建對象
stu1 = Student()
# 調用方法
stu1.study()
"""
面向對象特徵:
1.封裝
類的封裝
屬性(成員變量)
動態添加屬性:
對象名.屬性名 = value
訪問屬性:
對象名.屬性名
爲類模板添加屬性:
__init__(self)方法
創建對象時會被調用
每創建一個對象都會被調用一次
行爲(成員函數<方法>)
2.繼承
3.多態
"""
class Student:
def __init__(self,name_,age_):
print('我是初始化方法,現在被調用了')
self.name = name_
self.age = age_
# 打印self的地址
print(id(self))
def study(self):
print('我愛學習,一天不寫代碼,難受~~~')
# 創建對象
stu1 = Student('小強',18)
print(id(stu1))
# 動態爲對象添加屬性
# stu1.name = '小明'
# stu1.age = 18
# # 打印對應的鍵值對屬性
print(stu1.__dict__)
print(dir(stu1))
# # print(dir(Student))
# print(stu1.name)
# print(stu1.age)
# # 調用方法
# stu1.study()
print('------------------')
stu2 = Student('鐵錘',20)
print(id(stu2))
print(dir(stu2))
print(stu2.__dict__)
# print(stu2.name)
"""
面向對象:
1.把類封裝好
2.處理類與類之間的關係
屬性/方法的訪問方式:
對象.屬性/方法
self 關鍵字的用法:
作爲方法的第一形參:
表示的當前類的一個對象,哪個對象調用,這個self表示的就是誰
訪問當前類的屬性:
訪問當前類的方法:
"""
class Student(object):
def __init__(self,name,age):
self.name = name
self.age = age
def sleep(self):
self.play_game()
print('閉上眼睛,躺牀上睡')
def play_game(self):
print('玩把遊戲')
# self.sleep()
def introduce(self):
print(f'introduce:{id(self)}')
print(f'我叫{self.name},今年{self.age}歲')
stu1 = Student('小明',18)
#
# print(id(stu1))
# stu1.introduce()
# stu2 = None
# stu2.introduce()
stu3 = Student('小青',18)
stu3.introduce()
stu3.sleep()
"""
1.類的封裝
屬性
行爲
2.類的交互
方法(參數)
需求:
光明英雄
屬性:
名字
生命值
攻擊力
行爲
攻擊(黑暗)
普通攻擊(黑暗)
技能攻擊(黑暗)
黑暗英雄
屬性:
名字
生命值
攻擊力
行爲
攻擊(光明)
普通攻擊(光明)
技能攻擊(光明)
創建兩個英雄
while True:
互相傷害
判斷輸贏以及結束問題
"""
import random
import time
class Hero_Dark:
def __init__(self,name,hp,damage):
self.name = name
self.hp = hp
self.damage = damage
def attack(self,light_hero):
n = random.randint(1,1)
if n == 1:
self.attack_common(light_hero)
# 普通傷害
def attack_common(self,light_hero):
real_damage = self.damage + random.randint(5,20)
light_hero.hp -= real_damage
print(f'{self.name}普通攻擊{light_hero.name},{light_hero.name}損失生命值{real_damage},剩餘生命值{light_hero.hp}')
# 技能傷害
# def attack_skill(self, light_hero):
# pass
class Hero_Light:
def __init__(self, name, hp, damage):
self.name = name
self.hp = hp
self.damage = damage
def attack(self, dark_hero):
n = random.randint(1,1)
if n == 1:
self.attack_common(dark_hero)
def attack_common(self, dark_hero):
real_damage = random.randint(1,25)+self.damage
dark_hero.hp -= real_damage
print(f'{self.name}普通攻擊{dark_hero.name},{dark_hero.name}損失生命值{real_damage},剩餘生命值{dark_hero.hp}')
# 創建對象
hero_dark = Hero_Dark('小怪獸',10000,20)
hero_light = Hero_Light('奧特曼',8000,25)
# 持續性的互相傷害
count = 1
while True:
print(f'第{count}回合')
hero_light.attack(hero_dark)
if hero_dark.hp <= 0:
print(f'{hero_dark.name}輸了')
break
hero_dark.attack(hero_light)
if hero_light.hp <= 0:
print(f'{hero_light.name}輸了')
break
time.sleep(0.005)
count += 1
"""
1.類的封裝
屬性
行爲
2.類的交互
方法(參數)
需求:
光明英雄
屬性:
名字
生命值
攻擊力
行爲
攻擊(黑暗)
普通攻擊(黑暗)
技能攻擊(黑暗)
黑暗英雄
屬性:
名字
生命值
攻擊力
行爲
攻擊(光明)
普通攻擊(光明)
技能攻擊(光明)
創建兩個英雄
while True:
互相傷害
判斷輸贏以及結束問題
"""
import random
import time
# 技能類
class Skill:
def __init__(self,sk_name,sk_damage):
# 技能名
self.skill_name = sk_name
# 技能傷害值
self.skill_damage = sk_damage
class Hero_Dark:
def __init__(self,name,hp,damage,q,r):
self.name = name
self.hp = hp
self.damage = damage
self.skillQ = q
self.skillR = r
def attack(self,light_hero):
n = random.randint(1,2)
if n == 1:
self.attack_common(light_hero)
else:
self.attack_skill(light_hero)
# 普通傷害
def attack_common(self,light_hero):
real_damage = self.damage + random.randint(5,20)
light_hero.hp -= real_damage
print(f'{self.name}普通攻擊{light_hero.name},{light_hero.name}損失生命值{real_damage},剩餘生命值{light_hero.hp}')
# 技能傷害
def attack_skill(self, light_hero):
n = random.randint(1,2)
if n == 1:
light_hero.hp -= self.skillQ.skill_damage
print(f'{self.name}釋放技能\033[1;34m{self.skillQ.skill_name}\033[0m,{light_hero.name}損失生命值{self.skillQ.skill_damage},剩餘生命值{light_hero.hp}')
else:
light_hero.hp -= self.skillR.skill_damage
print(
f'{self.name}釋放技能{self.skillR.skill_name},{light_hero.name}損失生命值{self.skillR.skill_damage},剩餘生命值{light_hero.hp}')
class Hero_Light:
def __init__(self, name, hp, damage):
self.name = name
self.hp = hp
self.damage = damage
def attack(self, dark_hero):
n = random.randint(1,1)
if n == 1:
self.attack_common(dark_hero)
# 普通傷害
def attack_common(self, dark_hero):
real_damage = random.randint(1,25)+self.damage
dark_hero.hp -= real_damage
print(f'{self.name}普通攻擊{dark_hero.name},{dark_hero.name}損失生命值{real_damage},剩餘生命值{dark_hero.hp}')
# 技能傷害
def attack_skill(self,dark_hero):
pass
sk_Q = Skill('偷天換日',99)
sk_R = Skill('偷樑換柱',120)
# 創建對象
hero_dark = Hero_Dark('小怪獸',1000,20,sk_Q,sk_R)
hero_light = Hero_Light('奧特曼',850,25)
# 持續性的互相傷害
count = 1
# print("\033[1;32m 字體顏色:深黃色\033[0m")
while True:
print(f'第{count}回合')
hero_light.attack(hero_dark)
if hero_dark.hp <= 0:
print(f'{hero_dark.name}輸了')
break
hero_dark.attack(hero_light)
if hero_light.hp <= 0:
print(f'{hero_light.name}輸了')
break
time.sleep(0.25)
count += 1
"""
私有化:
私有屬性:
語法:
self.__屬性名 = value
私有屬性,不可以在類外訪問(獲取值)
直接在類外,爲私有屬性設置值(無效)
注意:
對於私有屬性,一般情況會提供對應的讀寫方法(setXXX() getXXX())
不是真正上的私有化,而是名字重整(改名)
私有方法:
def __方法名(參數):
pass
私有方法只能類內使用,不能類外訪問
符合名字重整的原則:
_類名__私有方法/屬性名
"""
class Student:
def __init__(self,name,age):
self.name = name
# self.age = age
# 私有屬性
# self.__age = age
self.setAge(age)
def setAge(self,age):
if 0 < age <= 120:
self.__age = age
else:
print('年齡有誤,默認設置1')
self.__age = 1
def getAge(self):
return self.__age
def introduce(self):
print(f'我叫{self.name},今年{self.__age}歲')
self.__func1()
# 類內定義的私有方法
def __func1(self):
print(f'我是私有方法:__func1')
stu1 = Student('鼠標',2300)
# stu1.__age = -3
# 不能在類外直接訪問私有屬性
# print(f'年齡:{stu1.__age}')
# 通過修改年齡的方法,修改年齡值
stu1.setAge(19)
print(stu1.getAge())
# 通過重整之後的名字訪問私有屬性(不提倡)
# stu1._Student__age = 1000
# stu1.introduce()
print(dir(stu1))
# 無法通過對象訪問私有方法
# stu1.__func1()
# 訪問名字重整後的方法(不提倡)
stu1._Student__func1()
"""
面向對象:
1.封裝
2.繼承
查閱資料(瞭解類與類之間的關係)
父類(超類,根類,基類)
子類(孩子類,派生類)
繼承的語法:
class 類名(父類):
pass
繼承的作用:
子類可以訪問父類中所有的非私有的屬性,方法
繼承的好處:
減少重複代碼(減少代碼冗餘度)
易拓展,易維護
如果一個類,沒有明確指明父類是誰,則默認父類是object
class 類名(object):
pass
3.多態
"""
class Dog:
def __init__(self,name,color,age):
self.name = name
self.color = color
self.age = age
def shout(self):
print('會叫~~~~')
def lookafter_home(self):
print('看家')
class Cat:
def __init__(self, name, color, age):
self.name = name
self.color = color
self.age = age
def shout(self):
print('會叫~~~~')
def catch_mouse(self):
print('貓抓耗子')
class Pig:
def __init__(self, name, color, age):
self.name = name
self.color = color
self.age = age
def shout(self):
print('會叫~~~~')
dog1 = Dog('大黃','yellow',3)
cat1 = Cat('小黑','black',2)
dog1.shout()
dog1.lookafter_home()
cat1.shout()
cat1.catch_mouse()
"""
面向對象:
1.封裝
2.繼承
查閱資料(瞭解類與類之間的關係)
父類(超類,根類,基類)
子類(孩子類,派生類)
繼承的語法:
class 類名(父類):
pass
繼承的作用:
class 類名(object):
pass
3.多態
"""
class Animal:
def __init__(self, name, color, age):
self.name = name
self.color = color
self.age = age
def shout(self):
print('會叫~~~~')
def __sleep(self):
print('私有方法睡覺')
class Dog(Animal):
def lookafter_home(self):
print('看家')
class Cat(Animal):
def catch_mouse(self):
print('貓抓耗子')
class Pig(Animal):
pass
dog1 = Dog('大黃','yellow',3)
cat1 = Cat('小黑','black',2)
dog1.shout()
print(dog1.name)
dog1.lookafter_home()
cat1.shout()
cat1.catch_mouse()
# cat1.__sleep()
# 查看Cat的父類
print(Cat.__bases__)
print(Animal.__bases__)
"""
__init__(self)
調用時機:
創建對象會被調用,每創建一個對象,都會被調用一次
作用:
爲類模板添加屬性
做對象初始化的處理
self關鍵字的意義:
self表示的當前類的一個對象
誰調用的時候,表示的就是誰
可以訪問當前類的屬性以及方法
封裝中私有化問題:
語法:
私有屬性:
self.__屬性名()
提供讀寫方法:
讀:
def get屬性():
寫:
def set屬性(self,形參)
self.屬性 = 形參
私有方法:
def __方法名()
私有化後的影響:
私有化的屬性/方法,只能類內訪問
不能類外訪問
python中的私有化,不是真正的私有化:本質是名字重整
重整規則:
屬性: _類名__私有屬性名
方法: _類名__私有方法名
繼承:
語法:
class 子類(父類):
pass
class 子類: #不指明父類,則默認父類爲object
pass
作用:
子類可以繼承父類中所有非私有的屬性,跟方法
好處:
精簡代碼
易維護,易拓展
"""
"""
1.封裝狙擊手類
屬性:
名字
槍 = None
行爲:
撿槍(槍)
裝彈<創建彈夾,循環創建子彈,裝進彈夾裏,然後把彈夾裝到槍上>
瞄準(敵人)
射擊(敵人)<調用槍的射擊方法>
2.封裝槍類
屬性:
型號
彈夾=None
行爲:
射擊(敵人)<打出一顆子彈>
"""
import time
class Sniper:
def __init__(self,name):
self.name = name
self.gun = None
# 撿槍, 參數gun就是要撿起來的槍
def pickup_gun(self,gun):
self.gun = gun
print(f'狙擊手【{self.name}】撿起一把【{gun.type}】')
# 裝彈
def load(self):
# 創建一個彈夾對象
clip = Clip(10)
# 循環裝子彈
print('裝彈中')
for i in range(clip.capacity):
time.sleep(0.2)
print(f'第{i+1}發')
bullet = Bullet()
clip.bullet_list.append(bullet)
print('裝彈完成')
# 將彈夾裝到槍上
self.gun.clip = clip
class Gun:
def __init__(self,type):
self.type = type
# 彈夾屬性值爲None
self.clip = None
# 彈夾類
class Clip:
def __init__(self,capacity):
# 彈夾容量
self.capacity = capacity
# 存儲子彈對象的容器
self.bullet_list = []
# 子彈類
class Bullet:
def __init__(self):
# 子彈傷害值
self.damage = 100
self.speed = 100
def move(self):
print('讓子彈飛一會~~~')
# 創建選手
sniper = Sniper('001')
# 創建槍
gun = Gun('AWM')
# 選手撿槍
sniper.pickup_gun(gun)
# 裝彈
sniper.load()
"""
1.封裝狙擊手類
屬性:
名字
槍 = None
行爲:
撿槍(槍)
裝彈<創建彈夾,循環創建子彈,裝進彈夾裏,然後把彈夾裝到槍上>
瞄準(敵人)
射擊(敵人)<調用槍的射擊方法>
2.封裝槍類
屬性:
型號
彈夾=None
行爲:
射擊(敵人)<打出一顆子彈>
3.封裝彈夾類
屬性:
彈夾容量
存儲子彈的列表
4.封裝子彈類
屬性:
傷害值
行爲:
移動
"""
import time
class Sniper:
def __init__(self,name):
self.name = name
self.gun = None
# 撿槍, 參數gun就是要撿起來的槍
def pickup_gun(self,gun):
self.gun = gun
print(f'狙擊手【{self.name}】撿起一把【{gun.type}】')
# 裝彈
def load(self):
# 創建一個彈夾對象
clip = Clip(10)
# 循環裝子彈
print('裝彈中')
for i in range(clip.capacity):
time.sleep(0.2)
print(f'第{i+1}發')
bullet = Bullet()
clip.bullet_list.append(bullet)
print('裝彈完成')
# 將彈夾裝到槍上
self.gun.clip = clip
# 瞄準
def aim_at(self,enemy):
print(f'瞄準敵人{enemy.name}')
# 調用射擊
self.shoot(enemy)
# 射擊
def shoot(self,enemy):
print('扣動扳機,砰~~~')
# 調用槍的射擊,得到一顆子彈
bullet = self.gun.shoot(enemy)
# 子彈飛向敵人
bullet.move(enemy)
class Gun:
def __init__(self,type):
self.type = type
# 彈夾屬性值爲None
self.clip = None
# 射擊
def shoot(self,enemy):
# 彈夾中的子彈數量-1
b = self.clip.bullet_list.pop()
print(f'打出一顆子彈,剩餘子彈{len(self.clip.bullet_list)}發')
return b
# 彈夾類
class Clip:
def __init__(self,capacity):
# 彈夾容量
self.capacity = capacity
# 存儲子彈對象的容器
self.bullet_list = []
# 子彈類
class Bullet:
def __init__(self):
# 子彈傷害值
self.damage = 100
self.speed = 100
def move(self,enemy):
print(f'子彈飛向敵人{enemy.name}')
# 敵人中彈
enemy.get_shot(self)
# 敵人類
class Enemy:
def __init__(self,name):
self.name = name
self.hp = 100
# 被打中之後的行爲
def get_shot(self,bullet):
self.hp -= bullet.damage
print(f'【{self.name}】中彈,剩餘生命值:【{self.hp}】')
# 創建選手
sniper = Sniper('001')
# 創建槍
gun = Gun('AWM')
# 選手撿槍
sniper.pickup_gun(gun)
# 裝彈
sniper.load()
# 創建一個敵人
enemy = Enemy('伏地魔')
# 調用選手的瞄準方法
sniper.aim_at(enemy)
"""
多繼承條件下的super的意義:
super 表示直接找父類,而是取決於__mro__的順序
python3 廣度優先的搜索算法
python2下:
如果是舊式類(經典類):
深度優先
如果是新式類
廣度優先
"""
class A:
def func(self):
print('A.func')
class B(A):
def func(self):
print('B.func')
super(B, self).func()
class C(A):
def func(self):
print('C.func')
super(C, self).func()
class D(B,C):
def func(self):
print('D.func')
# super(D, self).func()
# super(self.__class__).func()
d = D()
d.func()
print(D.__mro__)# d->b->c->a
#運行結果
# D.func
# (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
"""
封裝
繼承
多態:
繼承是前提,沒有繼承就沒有多態
方法重寫
多態:指的是方法的多態
同一個方法名,由於調用對象的不同,可能會有不同的執行效果
不同國家的人喫飯
"""
class Human:
def eat(self):
print('人都需要喫飯')
class Chinese(Human):
def eat(self):
print('中國人使用筷子喫飯')
class Indian(Human):
def eat(self):
print('三個使用手抓飯')
class English(Human):
def eat(self):
print('英國人使用刀叉喫飯')
# p = Human()
p = Chinese()
p.eat()
"""
# 抽象類:
# 什麼是抽象類?
# 包含抽象方法的類,就是抽象類
#
# 抽象方法?
# class Animal(metaclass=ABCMeta)
# @abstractmethod
#
# 抽象類與普通類的區別?
# 是否包含抽象方法
#
# 抽象類的特性:
# 不能實例化(不能創建對象)
#
# 作用:
# 可以規範子類的行爲(要求子類必須重寫父類中的抽象方法,如果不重寫,子類依舊是抽象類)
#
# 什麼場景下使用抽象類?
# 對於不適合創建對象的類
#
# """
# from abc import abstractmethod,ABCMeta
# class Animal(metaclass=ABCMeta):
# a = 10
# @abstractmethod
# def shout(self):
# print('動物會叫')
# # @abstractmethod
# def eat(self):
# print('動物都需要喫東西')
#
# #TypeError: Can't instantiate abstract class Animal with abstract methods shout
# # a = Animal()
#
# class Dog(Animal):
# def shout(self):
# print('汪汪汪~~~')
# dog1 = Dog()
# dog1.shout()
# dog1.eat()
# print(dog1.a)
"""
魔法方法(magic method):
不用手動調用,在一定場景下,會被自動觸發的方法,稱爲魔法
特點:
__方法名__()
注意:
自定義方法避免使用這種方式
__str__()
"""
class Dog:
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return f'name:{self.name} age:{self.age}'
dog1 = Dog('大黃',3)
print(dog1)
# python 會默認執行 dog1.__str__()
print(dog1.__str__())
"""
__call__
一個對象被當成方法調用時,會自動執行
__repr__
用法類似__str__,是__str__的備胎
"""
class A:
def __init__(self,v1,v2):
self.v1 = v1
self.v2 = v2
def __call__(self, *args, **kwargs):
print('__call__被調用')
print(args,kwargs)
def __repr__(self):
return f'repr :v1 = {self.v1}, v2 = {self.v2}'
def __str__(self):
return f'str: v1 = {self.v1}, v2 = {self.v2}'
# a = A()
# a(1,2,3)
a = A(1,2)
# print(a)
print('%r'%a)
print('%s'%a)
"""
__new__:
創建對象時,分配內存的時候會被自動觸發
__del__
當對象要被系統回收時,會被觸發
"""
class A:
def __new__(cls, *args, **kwargs):
print('__new__')
return super().__new__(cls)
def __init__(self,name):
print('__init__')
self.name = name
def __del__(self):
print('__del__')
print(f'{self.name}要被系統收走了')
def func1():
a0 = A('葫蘆爺爺')
func1()
a1 = A('大娃')
a2 = A('二娃')
a3 = A('三娃')
a4 = A('四娃')
while True:
pass