python零基礎一

“”"
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 = {同列表推導式}
    # 唯一，無序

面試試題：

1. def func(lst=[])
   內部保留lst之前的值
2. 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’))

“”"

1. 什麼是模塊？
   一個.py文件就被稱爲一個模塊
   2.模塊的分類
   2.1 內置模塊
   2.2 系統標準模塊
   random
   time
   sys
   2.3 第三方模塊
   pygame

   2.4 自定義模塊

2. 模塊中的內容（可以寫任意內容）
   變量
   函數
   可執行的代碼

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