[TOC]
## **第1章 字符串練習題**
<details>
<summary>1.1 交換</summary>
```
'''
1.1交換
已知 a的值為"hello",b的值為"world",如何交換a和b的值?
得到a的值為"world",b的值為"hello"
'''
a = "hello"
b = "world"
a,b = b,a
print("a的值為 %s" % a)
print("b的值為 %s" % b)
```
</details>
<br />
<details>
<summary>1.2 回文</summary>
```
'''
1.2回文
回文的定義:"回文" 就是正讀倒讀都一樣的。
如奇數個:"98789",這個數字正讀是"98789" 倒讀也是"98789"。
偶數個數字"3223"也是回文數。
字母 "abcba" 也是回文。
判斷一個字符串是否是回文字符串,是打印True, 不是打印False
'''
# 方法一
a = input("請輸入一個數字:")
b = a[::-1]
if a == b:
print("該數字是回文數")
else:
print("該數字不是回文數")
# 方法二
a = int(input("請輸入一個數字:\n"))
x = str(a)
flag = True
for i in range(len(x)//2):
if x[i] != x[-i - 1]:
flag = False
break
if flag:
print ("%d 是一個回文數!" % a)
else:
print ("%d 不是一個回文數!" % a)
```
</details>
<br />
<details>
<summary>1.3字符串切割</summary>
```
'''
1.3字符串切割
已知一個字符串為 "hello_world_yoyo", 如何得到一個隊列 ["hello","world","yoyo"]
'''
str = "hello_world_bigant"
str1 = str.split("_")
print(str1)
```
</details>
<br />
<details>
<summary>1.4拼接字符串</summary>
```
# 方法一
lister = ["hello", "world", "yoyo"]
s = "hello_" + "world_" + "yoyo"
print(s)
# 方法二
lister = ["hello", "world", "yoyo"]
strlist = '_'.join(lister)
print(strlist)
```
</details>
<br />
<details>
<summary>1.5替換字符</summary>
```
'''
1.5替換字符
把字符串 s 中的每個空格替換成"%20"
輸入:s = "We are happy."
輸出:"We%20are%20happy."
'''
s = "We are happy."
print(s.replace(" ", "%20"))
```
</details>
<br />
<details>
<summary>1.6九九乘法表</summary>
```
# 打印99乘法表
# 方法一
for i in range(1, 10):
for j in range(1, i+1):
print("%d*%d=%d" % (j, i, j*i), end=' ')
print("")
# 方法二
i = 1
while i<10:
j = 1
while j <= i:
print("%d*%d=%d" % (j,i,j*i), end=' ')
j += 1
print("")
i += 1
```
</details>
<br />
<details>
<summary>1.7字符下標</summary>
```
'''
找出單詞 "welcome" 在 字符串"Hello, welcome to my world." 中出現的位置,找不到返回-1
從下標0開始索引
'''
s = "Hello, welcome to my world."
print(s.index("welcome", 0, len(s)))
```
</details>
<br />
<details>
<summary>1.8 統計字符出現的次數</summary>
```
'''
統計字符串“Hello, welcome to my world.” 中字母w出現的次數
統計單詞 my 出現的次數
'''
str = "Hello, welcome to my world."
print("字母 w 出現的次數:", str.count("w"))
print("單詞 my 出現的次數:", str.count("my"))
```
</details>
<br />
<details>
<summary>1.9 統計每個字符出現的次數 </summary>
</details>
<br />
<details>
<summary>1.10 判斷字符a含b </summary>
```
'''
判斷字符串a="welcome to my world" 是否包含單詞b="world"
包含返回True,不包含返回 False
'''
a = "welcome to my world"
b = "world"
if b in a:
print(True)
else:
print(False)
```
</details>
<br />
<details>
<summary>1.11 查找字符首次出現位置 </summary>
```
'''
輸出指定字符串A在字符串B中第一次出現的位置,如果B中不包含A,則輸出-1
從 0 開始計數
A = "hello"
B = "hi how are you hello world, hello yoyo !"
'''
A = "hello"
B = "hi how are you hello world, hello yoyo !"
# if A in B:
print(B.find(A))
# 或者
print(B.index(A))
```
</details>
<br />
<details>
<summary>1.12 查找字符串最后一次出現位置 </summary>
```
'''
輸出指定字符串A在字符串B中最后出現的位置,如果B中不包含A,則輸出-1
從 0 開始計數
A = "hello"
B = "hi how are you hello world, hello yoyo !"
'''
A = "hello"
B = "hi how are you hello world, hello yoyo !"
print(B.rfind(A))
```
</details>
<br />
<details>
<summary>1.13判斷奇數偶數 </summary>
```
'''
給定一個數a,判斷一個數字是否為奇數或偶數
a1 = 13
a2 = 10
'''
num = int(input("請輸入一個整數:"))
if num % 2 == 0:
print("這是一個偶數")
elif num % 2 == 1:
print("這是一個奇數")
```
</details>
<br />
<details>
<summary>1.14判斷一個姓名是否姓王 </summary>
</details>
<br />
<details>
<summary>1.15判斷是不是數字 </summary>
```
'''
如何判斷一個字符串是不是純數字組成
a = "123456"
b = "yoyo123"
'''
str1 = "123456"
str2 = "Abcd"
str3 = "123Abc"
# 用isdigit函數判斷是否數字
print(str1.isdigit())
print(str2.isdigit())
print(str3.isdigit())
# 用isalpha判斷是否字母
print(str1.isalpha())
print(str2.isalpha())
print(str3.isalpha())
# isalnum判斷是否數字和字母的組合
print(str1.isalnum())
print(str2.isalnum())
print(str3.isalnum())
# 注意:如果字符串中含有除了字母或者數字之外的字符,比如空格,也會返回False
```
</details>
<br />
<details>
<summary>1.16字符串大小寫轉換 </summary>
```
'''
將字符串 a = "This is string example....wow!" 全部轉成大寫
字符串 b = "Welcome To My World" 全部轉成小寫
'''
a = "This is string example....wow!"
b = "Welcome To My World"
# 全部轉成大寫
print(a.upper())
# 全部轉成小寫
print(b.lower())
# 字符串首字母大寫
print(a.capitalize())
# 每個單詞的首字母大寫
print(a.title())
# 大小寫互換
print(b.swapcase())
```
</details>
<br />
<details>
<summary>1.17 去掉字符串中空格的方法 </summary>
```
'''
將字符串 a = " welcome to my world "首尾空格去掉
'''
a = " welcome to my world "
# 去除字符串開頭和結尾的空格
print(a.strip())
# 去除字符串開頭的空格
print(a.lstrip())
# 去掉字符串結尾的空格
print(a.rstrip())
# 去除全部空格
'''
1. replace()方法
replace主要用于字符串的替換replace(old, new, count)
'''
print(a.replace(" ", ""))
'''
2.join()方法+split()方法
# join可以將列表每個字符通過前字符串進行拼接,split可以將字符串按指定規則進行切割生成一個新的列表,
不傳參默認按空格切割
'''
print(a.split()) # 字符串按空格分割成列表b
print("".join(a.split())) # 使用一個空字符串合成列表內容生成新的字符串
```
</details>
<br />
<details>
<summary>1.18 字符串去重后排序 </summary>
```
'''
s = "ajldjlajfdljfddd",去重并從小到大排序輸出"adfjl"
1.22 字符串去重保留順序
s = "ajldjlajfdljfddd",去重保留原來的順序,輸出"adfjl"
'''
s = "ajldjlajfdljfddd"
s1 = list(set(s))
s2 = s1.sort(reverse=False)
s3 = "".join(s1)
print(s3)
```
s = set(s)
set() 函數創建一個無序不重復元素集,可進行關系測試,刪除重復數據,還可以計算交集、差集、并集等。
s = list(s)
將不重復的元素集s,轉換成Python常用的列表元素
**sort()** 函數用于對原列表進行排序,如果指定參數,則使用比較函數指定的比較函數。
**語法**
sort()方法語法:
```
list.sort(cmp=None, key=None, reverse=False)
```
參數
* cmp -- 可選參數, 如果指定了該參數會使用該參數的方法進行排序。
* key -- 主要是用來進行比較的元素,只有一個參數,具體的函數的參數就是取自于可迭代對象中,指定可迭代對象中的一個元素來進行排序。
* reverse -- 排序規則,reverse = True 降序, reverse = False 升序(默認)。
**返回值**
該方法沒有返回值,但是會對列表的對象進行排序。
</details>
<br />
<details>
<summary>1.23畫菱形 </summary>
題目 打印出如下圖案(菱形):

```
n = int(input("請輸入菱形邊長:"))
for i in range(n):
for j in range(n-i-1):
print(" ", end="")
for k in range(2*i+1):
print("*", end="")
print("")
for i in range(n-1):
for j in range(i+1):
print(' ', end='')
for k in range(2*(n-i)-3):
print("*", end="")
print()
```
</details>
<br />
<details>
<summary>1.24 輸入一個正整數,判斷是幾位數 </summary>
```
'''
題目 給一個不多于5位的正整數,要求:
一、求它是幾位數,
二、逆序打印出各位數字。
a = 12345
'''
s = int(input("請輸入一個整數:"))
print(s)
s1 = str(s)
print("您輸入的是 %s位數" % len(s1))
print("逆序的結果為:", end="")
for i in range(len(s1)-1, -1, -1): # 切片用法:創建一個與原字符串順序相反的字符串
print(s1[i], end="")
```
</details>
<br />
## **第2章 小學數學題**
<details>
<summary>2.1.水仙花數 </summary>
```
'''
如果一個 3 位數等于其各位數字的立方和,則稱這個數為水仙花數。
例如:153 = 1^3 + 5^3 + 3^3,因此 153 就是一個水仙花數
那么問題來了,求1000以內的水仙花數(3位數)
'''
for n in range(100, 1000):
i = n // 100
j = n // 10 % 10
k = n % 10
if n == i*i*i + j*j*j + k*k*k:
print(n)
```
</details>
<br />
<details>
<summary>2.2完全數 </summary>
```
'''
如果一個正整數等于除它本身之外其他所有除數之和,就稱之為完全數。
例如:6是完全數,因為6 = 1+2+3;
下一個完全數是28 = 14+7+4+2+1。
求1000以下的完全數
'''
L = []
for n in range(1, 1000):
sum = 0
for i in range(1, n):
if n % i == 0:
sum += i
if n == sum:
L.append(n)
print("1000以下的完全數有:%s" % L)
```
</details>
<br />
<details>
<summary>2.3 數字1-100求和 </summary>
```
'''
求1+2+3…+100和
'''
sum = 0
for n in range(1, 100):
sum += n
print(sum)
```
</details>
<br />
<details>
<summary>2.4計算求1-2+3-4+5-…-100的值 </summary>
```
'''
2.4計算求1-2+3-4+5-…-100的值
計算求1-2+3-4+5-…-100的值
邏輯整理:
-- 本質上可以轉換一下,1+3+5+……+99 -(2+4+……+100)
加減部分間隔都為2,先求1+3+5+……+99的值,
再求2+4+……+100的值,減去結果就出來了
'''
sum1 = 0
sum2 = 0
for n in range(1, 100, 2):
sum1 += n
for m in range(0, 101, 2):
sum2 += m
print(sum1 - sum2)
```
</details>
<br />
<details>
<summary>2.5計算求1+2-3+4-5... ...100 的值 </summary>
</details>
<br />
<details>
<summary>2.6計算 1-n 之間的所有 5 的倍數之和 </summary>
```
'''
定義一個函數:計算 1-n 之間的所有 5 的倍數之和,默認計算 1-100 ( n 是 一個整數)
'''
def sum(n):
sum = 0
for i in range(0, n, 5):
sum += i
print(sum)
sum(100)
```
</details>
<br />
<details>
<summary>2.7 n個自然數的立方和 </summary>
```
'''
2.7 n個自然數的立方和
計算公式 1^3 + 2^3 + 3^3 + 4^3 + …….+ n^3
實現要求:
輸入 : n = 5
輸出 : 225
對應的公式 : 1^3 + 2^3 + 3^3 + 4^3 + 5^3 = 225
'''
def sum(n):
sum = 0
for i in range(1, n+1):
sum += i*i*i
return sum
print(sum(5))
```
</details>
<br />
<details>
<summary>2.8 階乘10! </summary>
```
'''
2.8 階乘10!
階乘的意思: 10!=10x9x8x7x6x5x4x3x2x1
求10!
'''
# 方法一
def factorial(n):
factorials = 1
for i in range(1, n + 1):
factorials *= i
print("%d 的階乘為 %d" % (n, factorials))
factorial(10)
# 方法二
num = int(input("請輸入一個數字: "))
factorial = 1
# 查看數字是負數,0 或 正數
if num < 0:
print("抱歉,負數沒有階乘")
elif num == 0:
print("0 的階乘為 1")
else:
for i in range(1,num + 1):
factorial = factorial*i
print("%d 的階乘為 %d" %(num,factorial))
```
</details>
<br />
<details>
<summary>2.9求1+2!+3!+...+10!的和 </summary>
```
'''
2.9求1+2!+3!+...+10!的和
求1+2!+3!+...+10!的和
'''
def factorial(n):
factorials = 1
for i in range(1, n + 1):
factorials *= i
return factorials
def getSum(n):
sum = 0
for x in range(1, n + 1):
sum += factorial(x)
return sum
print(factorial(10))
print(getSum(10))
```
</details>
<br />
<details>
<summary>2.10求s=a+aa+aaa+aaaa+aa...a的值 </summary>
</details>
<br />
<details>
<summary> 2.11 斐波那契數列1、1、2、3、5、8、13 .....</summary>
```
'''
2.11 斐波那契數列1、1、2、3、5、8、13 .....
已知一個數列:1、1、2、3、5、8、13....的規律為從 3 開始的每一項都等于其前兩項的和,這是斐波那契數列。
求滿足規律的 100 以內的所有數據
'''
a = 0
b = 1
while b <= 100:
print(b, end=",")
a, b = b, a+b
```
</details>
<br />
## **第3章 列表練習題**
<details>
<summary>3.1 反轉(判斷對稱) </summary>
```
'''
3.1 反轉(判斷對稱)
如何判斷一個數組是對稱數組:
要求:判斷數組元素是否對稱。例如[1,2,0,2,1],[1,2,3,3,2,1]這樣的都是對稱數組
用Python代碼判斷,是對稱數組打印True,不是打印False,如:
x = [1, "a", 0, "2", 0, "a", 1]
'''
# 方法一
def isPalindrome(s):
new_list = s[::-1]
if s == new_list:
return True
else:
return False
print(isPalindrome("abcd"))
print(isPalindrome("12abc"))
print(isPalindrome("123321"))
print(isPalindrome("1a2b2a1"))
# 方法二
def isPalindrome(s):
return True if s == s[::-1] else False
if __name__ =='__main__':
print(isPalindrome("abcd"))
print(isPalindrome("12abc"))
print(isPalindrome("123321"))
print(isPalindrome("1a2b2a1"))
```
</details>
<br />
<details>
<summary>3.2列表切片 </summary>
```
'''
3.2列表切片
如果有一個列表a=[1,3,5,7,11]
問題:1如何讓它反轉成[11,7,5,3,1]
2.取到奇數位值的數字,如[1,5,11]
'''
a = [1, 3, 5, 7, 11]
b = a[::-1]
print(b)
print(a[::2])
```
</details>
<br />
<details>
<summary>3.3列表大小排序 </summary>
```
'''
3.3列表大小排序
問題:對列表a 中的數字從小到大排序
a = [1, 6, 8, 11, 9, 1, 8, 6, 8, 7, 8]
'''
a = [1, 6, 8, 11, 9, 1, 8, 6, 8, 7, 8]
b = sorted(a, reverse=False)
print(b)
```
</details>
<br />
<details>
<summary>3.4 取出最大值最小值 </summary>
```
'''
3.4 取出最大值最小值
L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
找出列表中最大值和最小值
'''
a = [1, 6, 8, 11, 9, 1, 8, 6, 8, 7, 8]
b = sorted(a, reverse=False)
print("列表中的最小值為:", b[0])
print("列表中的最大值為:", b[-1])
# 或者
print("列表中的最小值為:", min(a))
print("列表中的最大值為:", max(a))
```
</details>
<br />
<details>
<summary>3.5 找出列表中單詞最長的一個 </summary>
```
'''
3.5 找出列表中單詞最長的一個
a = ["hello", "world", "yoyo", "congratulations"]
找出列表中單詞最長的一個
'''
a = ["hello", "world", "yoyo", "congratulations"]
best = 0
for index in range(len(a)):
if len(a[index]) > len(a[best]):
best = index
print(a[best])
```
</details>
<br />
<details>
<summary>3.6 切片取出列表中最大的三個數 </summary>
```
'''
3.6 切片取出列表中最大的三個數
取出列表中最大的三個值
L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
'''
L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
L2 = sorted(L1, reverse=True)
print("列表中最大的三個值為:", L2[:3])
```
</details>
<br />
<details>
<summary>3.7列表按絕對值排序 </summary>
```
'''
3.7列表按絕對值排序
a = [1, -6, 2, -5, 9, 4, 20, -3] 按列表中的數字絕對值從小到大排序
'''
a = [1, -6, 2, -5, 9, 4, 20, -3]
b = sorted(a, key=abs, reverse=False)
print(b)
```
</details>
<br />
<details>
<summary>3.8 按字符串長度排序 </summary>
```
'''
3.8 按字符串長度排序
b = ["hello", "helloworld", "he", "hao", "good"]
按list里面單詞長度倒序
'''
b = ["hello", "helloworld", "he", "hao", "good"]
lst = sorted(b, key=len, reverse=True)
print(lst)
```
</details>
<br />
<details>
<summary>3.9 去重與排序 </summary>
```
'''
3.9 去重與排序
L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
如何用一行代碼得出[1, 2, 3, 5, 11, 33, 88]
L2 = [1, 2, 3, 4, 5] ,L[10:]結果是多少(報錯?還是None,還是[])
'''
L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
L2 = list(set(L1))
L3 = sorted(L2, reverse=False)
print(L3)
```
</details>
<br />
<details>
<summary>3.10 去重保留順序 </summary>
```
'''
3.10 去重保留順序
將列表中的重復值取出(僅保留第一個),要求保留原始列表順序
如a=[3, 2, 1, 4, 2, 6, 1] 輸出[3, 2, 1, 4, 6]
'''
# 方法一
a = [3, 2, 1, 4, 2, 6, 1]
a1 = []
for i in a:
if not i in a1:
a1.append(i)
print(a1)
# 方法二
a = [3, 2, 1, 4, 2, 6, 1]
a1 = sorted(set(a), key=a.index)
print(a1)
```
</details>
<br />
<details>
<summary>3.11 列表合并 </summary>
```
'''
3.11 列表合并
a = [1, 3, 5, 7]
b = ['a', 'b', 'c', 'd']
如何得到[1, 3, 5, 7, 'a', 'b', 'c', 'd']
'''
a = [1, 3, 5, 7]
b = ['a', 'b', 'c', 'd']
print(a+b)
# 使用extend方法
a.extend(b)
print(a)
# 使用切片
c = a[len(a):len(b)]
print(a)
```
</details>
<br />
<details>
<summary>3.12 生成列表(列表推導式) </summary>
```
'''
3.12 生成列表(列表推導式)
用一行代碼生成一個包含 1-10 之間所有偶數的列表
'''
lis = [i for i in range(1, 10) if i%2 == 0]
print(lis)
```
</details>
<br />
<details>
<summary>3.13 列表成員的平方 </summary>
```
'''
3.13 列表成員的平方
列表a = [1,2,3,4,5], 計算列表成員的平方數,得到[1,4,9,16,25]
'''
a = [1,2,3,4,5]
# 方法一
def square(num):
return num*num
print(list(map(square, a)))
# 方法二
print(list(map(lambda num:num*num, a)))
# 方法三 list comprehensions
print([ num*num for num in a])
```
</details>
<br />
<details>
<summary> 3.14 找出列表大于0的數</summary>
```
'''
3.14 找出列表大于0的數
使用列表推導式,將列表中a = [1, 3, -3, 4, -2, 8, -7, 6]
找出大于0的數,重新生成一個新的列表
'''
a = [1, 3, -3, 4, -2, 8, -7, 6]
lis = [x for x in a if x>0]
print(lis)
```
</details>
<br />
<details>
<summary>3.15統計列表有多少大于0 </summary>
```
'''
3.15統計列表有多少大于0
統計在一個隊列中的數字,有多少個正數,多少個負數,
如[1, 3, 5, 7, 0, -1, -9, -4, -5, 8]
'''
lis = [1, 3, 5, 7, 0, -1, -9, -4, -5, 8]
lis1 = [x for x in lis if x>0]
lis2 = [x for x in lis if x<0]
print( "正數有%d個" % len(lis1))
print("負數有%d個" % len(lis2))
```
</details>
<br />
<details>
<summary>3.16 列表排除篩選 </summary>
```
'''
3.16 列表排除篩選
a = ["張三", "張四", "張五", "王二"] 如何刪除姓張的
'''
a = ["張三", "張四", "張五", "王二"]
# 方法一:切片
for name in a[:]:
if name.startswith("張"):
a.remove(name)
print(a)
```
startswith() 方法用于檢查字符串是否是以指定子字符串開頭,如果是則返回 True,否則返回 False。如果參數 beg 和 end 指定值,則在指定范圍內檢查。
**語法**
startswith()方法語法:
~~~
str.startswith(substr, beg=0,end=len(string));
~~~
**參數**
* str -- 檢測的字符串。
* substr -- 指定的子字符串。
* strbeg -- 可選參數用于設置字符串檢測的起始位置。
* strend -- 可選參數用于設置字符串檢測的結束位置。
</details>
<br />
<details>
<summary>3.17 列表過濾(filter) </summary>
```
'''
3.17 列表過濾(filter)
題1:有個列表a = [1, 3, 5, 7, 0, -1, -9, -4, -5, 8] 使用filter 函數過濾出大于0的數
題2:列表b = ["張三", "張四", "張五", "王二"] 過濾掉姓張的姓名
'''
a = [1, 3, 5, 7, 0, -1, -9, -4, -5, 8]
b = ["張三", "張四", "張五", "王二"]
def num(n):
return n > 0
a1 = filter(num, a)
print(list(a1))
def remove_zhang(x):
return not str(x).startswith("張")
print(list(filter(remove_zhang, b)))
# 也可以用lambda
print(list(filter(lambda x: not str(x).startswith("張"), b)))
```
</details>
<br />
<details>
<summary>3.18 過濾列表中不及格學生(filter) </summary>
```
'''
3.18 過濾列表中不及格學生(filter)
過濾掉列表中不及格的學生
a = [
{"name": "張三", "score": 66},
{"name": "李四", "score": 88},
{"name": "王五", "score": 90},
{"name": "陳六", "score": 56},
]
'''
a = [
{"name": "張三", "score": 66},
{"name": "李四", "score": 88},
{"name": "王五", "score": 90},
{"name": "陳六", "score": 56},
]
print(list(filter(lambda x:x.get("score") >= 60, a)))
```
</details>
<br />
<details>
<summary>3.19 找出列表中最大數出現的位置 </summary>
```
'''
3.19 找出列表中最大數出現的位置
有個列表 a = [1, 2, 3, 11, 2, 5, 88, 3, 2, 5, 33]
找出列表中最大的數,出現的位置,下標從0開始
'''
a = [1, 2, 3, 11, 2, 5, 88, 3, 2, 5, 33]
print(a.index(max(a)))
```
</details>
<br />
<details>
<summary>3.20找出列表中出現次數最多的元素 </summary>
```
'''
3.20找出列表中出現次數最多的元素
a = [
'my', 'skills', 'are', 'poor', 'I', 'am', 'poor', 'I',
'need', 'skills', 'more', 'my', 'ability', 'are',
'so', 'poor'
]
找出列表中出現次數最多的元素
'''
a = [
'my', 'skills', 'are', 'poor', 'I', 'am', 'poor', 'I',
'need', 'skills', 'more', 'my', 'ability', 'are',
'so', 'poor'
]
print(max(a, key=a.count))
```
</details>
<br />
<details>
<summary>3.21 分別統計列表中每個成員出現的次數 </summary>
```
'''
3.21 分別統計列表中每個成員出現的次數
a = [
'my', 'skills', 'are', 'poor', 'I', 'am', 'poor', 'I',
'need', 'skills', 'more', 'my', 'ability', 'are',
'so', 'poor'
]
'''
from collections import Counter
a = [
'my', 'skills', 'are', 'poor', 'I', 'am', 'poor', 'I',
'need', 'skills', 'more', 'my', 'ability', 'are',
'so', 'poor'
]
# 方法一
dict = {}
for key in a:
dict[key] = dict.get(key, 0) + 1
print(dict)
# 方法二
result = Counter(a)
print(result)
```
</details>
<br />
<details>
<summary>3.22 列表查找元素位置 </summary>
```
'''
3.22 列表查找元素位置
給定一個整數數組A及它的大小n,同時給定要查找的元素val,
請返回它在數組中的位置(從0開始),若不存在該元素,返回-1。
若該元素出現多次請返回第一個找到的位置
如 A1=[1, "aa", 2, "bb", "val", 33]
或 A2 = [1, "aa", 2, "bb"]
'''
# 方法一,index函數
A1=[1, "aa", 2, "bb", "val", 33]
print(A1.index("val"))
```
</details>
<br />
<details>
<summary>3.23 列表查找兩數之和 </summary>
考察點:
1、分支流程控制、循環流程控制
2、字符串常用方法a.index
3、字符串遍歷for num in nums
4、不要使用雙層for循環,可以成功,但是時間復雜度高
```
'''
3.23 列表查找兩數之和
給定一個整數數組nums 和一個目標值target ,請你在該數組中找出和為目標值的那兩個整數,
并返回他們的數組下標。
你可以假設每種輸入只會對應一個答案。但是,數組中同一個元素不能使用兩遍。
示例:
給定nums=[2,7,11,15],target=9
因為nums[0] + nums[1] =2+7 = 9
所以返回[0, 1]
'''
nums = [2, 7, 11, 1, 15, 8]
target = 9
result = []
for num1 in nums:
if num1 <= target:
num2 = target - num1
if num2 in nums:
flag1 = nums.index(num1)
flag2 = nums.index(num2)
if [flag1, flag2] not in result and [flag2, flag1] not in result:
result.append([flag1, flag2])
print(result)
```
</details>
<br />
<details>
<summary>3.24 二維數組取值(矩陣) </summary>
```
3.24 二維數組取值(矩陣)
有 a = [["A", 1], ["B", 2]] ,如何取出 2
```
</details>
<br />
<details>
<summary>3.25 二維數組拼接 </summary>
```
'''
3.25 二維數組拼接
a = [[1,2],[3,4],[5,6]] 如何一句代碼得到 [1, 2, 3, 4, 5, 6]
'''
```
</details>
<br />
<details>
<summary>3.26 列表轉字符串 </summary>
```
'''
3.26 列表轉字符串
L = [1, 2, 3, 5, 6],如何得出 '12356'?
'''
L = [1, 2, 3, 5, 6]
str = ''.join([str(x) for x in L])
print(str)
```
</details>
<br />
<details>
<summary>3.27 兩個列表如何得到字典 </summary>
```
'''
3.27 兩個列表如何得到字典
a = ["a", "b", "c"]
b = [1, 2, 3]
如何得到 {'a': 1, 'b': 2, 'c': 3}
'''
a = ["a", "b", "c"]
b = [1, 2, 3]
print(dict(zip(a, b)))
```
</details>
<br />
<details>
<summary>3.28 列表按age從小到大排序 </summary>
```
'''
3.28 列表按age從小到大排序
如下列表
people = [
{"name":"yoyo", "age": 20},
{"name":"admin", "age": 28},
{"name":"zhangsan", "age": 25},
]
按年齡age從小到大排序
'''
people = [
{"name":"yoyo", "age": 20},
{"name":"admin", "age": 28},
{"name":"zhangsan", "age": 25},
]
people.sort(key=lambda item:item.get("age"))
print(people)
```
</details>
<br />
<details>
<summary>3.29 列表插入元素 </summary>
```
'''
3.29 列表插入元素
現有 nums=[2, 5, 7],如何在該數據最后插入一個數字 9,如何在2后面插入數字0
'''
nums=[2, 5, 7]
nums.insert(3, 9)
print(nums)
nums.insert(1, 0)
print(nums)
```
</details>
<br />
<details>
<summary>3.30 打亂列表順序隨機輸出 </summary>
```
'''
3.30 打亂列表順序隨機輸出
有個列表a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
如何打亂列表a的順序,每次得到一個無序列表
'''
a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
random.shuffle(a)
print(a)
```
</details>
<br />
## **第4 章 元祖字典集合**
<details>
<summary>4.1 輸出1-100除3余1 的數,結果為tuple </summary>
</details>
<br />
<details>
<summary>4.2 把2個元組轉字典 </summary>
```
'''
4.2 把2個元組轉字典
將('a', 'b', 'c', 'd', 'e') 和 (1,2, 3, 4, 5)兩個tuple轉成
(1, 2, 3, 4, 5)為key, ('a', 'b', 'c', 'd', 'e') 為value的字典
'''
tup1 = ('a', 'b', 'c', 'd', 'e')
tup2 = (1, 2, 3, 4, 5)
dic = dict(zip(tup1, tup2))
print(dic)
```
</details>
<br />
<details>
<summary>4.3 把字典的value值轉成str </summary>
```
'''
4.3 把字典的value值轉成str
將字典里的值是數值型的轉換為字符串,如a = {'aa': 11, 'bb': 222}
得到{'aa': '11', 'bb': '222'}
'''
```
</details>
<br />
<details>
<summary>4.4 (1)和(1,)區別,[1]和[1,] </summary>
```
'''
4.4 (1)和(1,)區別,[1]和[1,]
a = [1,2,3] 和 b = [(1),(2),(3)] 以及 c = [(1,),(2,),(3,)] 的區別?
'''
```
如果要定義一個空的tuple,可以寫成`()`:
~~~
>>> t = ()
>>> t
()
~~~
但是,要定義一個只有1個元素的tuple,如果你這么定義:
~~~
>>> t = (1)
>>> t
1
~~~
定義的不是tuple,是`1`這個數!這是因為括號`()`既可以表示tuple,又可以表示數學公式中的小括號,這就產生了歧義,因此,Python規定,這種情況下,按小括號進行計算,計算結果自然是`1`。
所以,只有1個元素的tuple定義時必須加一個逗號`,`,來消除歧義:
~~~
>>> t = (1,)
>>> t
(1,)
~~~
</details>
<br />
<details>
<summary>4.5 map函數將[1,2,3,4]處理成[1,0,1,0] </summary>
```
'''
4.5 map函數將[1,2,3,4]處理成[1,0,1,0]
map函數,有個列表a = [1, 2, 3, 4] 計算列表中每個數除以2 取出余數 得到 [1,0,1,0]
'''
a = [1, 2, 3, 4]
a1 = list(map(lambda x: x % 2, a))
print(a1)
```
</details>
<br />
<details>
<summary>4.6 map函數將列表[1,2,3,4,5]轉變成[1,4,9,16,25] </summary>
```
'''
4.6 map函數將列表[1,2,3,4,5]轉變成[1,4,9,16,25]
map函數將列表 [1,2,3,4,5] 使用python方法轉變成 [1,4,9,16,25]
'''
a = [1, 2, 3, 4, 5]
a1 = list(map(lambda x: x * x, a))
print(a1)
```
</details>
<br />
<details>
<summary>4.7 map函數a=[1,3,5],b=[2,4,6]相乘得到[2,12,30] </summary>
```
'''
4.7 map函數a=[1,3,5],b=[2,4,6]相乘得到[2,12,30]
'''
a = [1, 3, 5]
b = [2, 4, 6]
c = list(map(lambda x, y: x * y, a, b))
print(c)
```
</details>
<br />
<details>
<summary>4.8 reduce函數計算1-100的和 </summary>
```
'''
4.8 reduce函數計算1-100的和
'''
from functools import reduce
# 方法一
print(reduce(lambda a,b:a+b, range(1, 101)))
# 方法二
def add(x, y):
return x+y
print(reduce(add, range(1, 101)))
```
</details>
<br />
<details>
<summary>4.9 reduce函數計算10!</summary>
```
'''
4.9 reduce函數計算10!
reduce函數計算1!+2!+3!+....+10!
'''
from functools import reduce
def fact(n):
return reduce(lambda a, b:a*b, range(1, n+1))
print(fact(10))
```
</details>
<br />
<details>
<summary>4.10 兩個字典合并 </summary>
```
'''
4.10 兩個字典合并
兩個字典合并a={"A":1,"B":2},b={"C":3,"D":4}
'''
a = {"A": 1, "B": 2}
b = {"C": 3, "D": 4}
# 方法一
def merge(a, b):
return a.update(b)
print(merge(a, b)) # 返回 None
print(a)
# 方法二
# 合并生成新dict的方式,使用 **前綴將多個字典鋪開,構造合并dict
c = {**a, **b}
print(c)
# 方法三
# 使用dict構造函數。dict的第一個參數可以是字典,后面的參數都是鍵值參數,因此可以用**y表示。
c = dict(a, **b)
print(c)
```
</details>
<br />
<details>
<summary>4.11 {'a':1,'b':2,'c':1} 得到 {1:['a','c'],2:['b']} </summary>
```
'''
4.11 {'a':1,'b':2,'c':1} 得到 {1:['a','c'],2:['b']}
m1={'a':1,'b':2,'c':1} # 將同樣的value的key集合在list里,輸出{1:['a','c'],2:['b']}
'''
```
</details>
<br />
<details>
<summary>4.12 字典按key排序c={"name":"zs","age":18} </summary>
```
'''
4.12 字典按key排序c={"name":"zs","age":18}
d={"name":"zs","age":18,"city":"深圳","tel":"1362626627"}
字典根據鍵從小到大排序
'''
c = {"name": "zs", "age": 18}
d = {"name": "zs", "age": 18, "city": "深圳", "tel": "1362626627"}
```
</details>
<br />
<details>
<summary>4.13 集合(交集、差集、并集) </summary>
```
'''
4.13 集合(交集、差集、并集)
a = [2, 3, 8, 4, 9, 5, 6]
b = [2, 5, 6, 10, 17, 11]
1.找出a和b中都包含了的元素
2.a或b中包含的所有元素
3.a中包含而集合b中不包含的元素
'''
a = [2, 3, 8, 4, 9, 5, 6]
b = [2, 5, 6, 10, 17, 11]
print(set(a) & set(b))
print(set(a) | set(b))
print(set(a) - set(b))
```
</details>
<br />
## **第5章 綜合練習題**
<details>
<summary>5.1 有1、2、3、4組成無重復數的三位數(排列組合) </summary>
```
'''
5.1 有1、2、3、4組成無重復數的三位數(排列組合)
有1、2、3、4數字能組成多少互不相同無重復數的三位數?
分別打印這些三位數的組合
'''
from itertools import permutations
# 方法一
for i in permutations('123', 3):
print(''.join(i))
# 方法二
result = {int(''.join(i)) for i in permutations('1234', 3)}
print(result)
```
</details>
<br />
<details>
<summary>5.2 冒泡排序 </summary>
```
'''
5.2 冒泡排序
a = [11, 2, 33, 1, 5, 88, 3]
冒泡排序:
依次比較兩個相鄰的元素,如果順序(如從小到大、首字母從A到Z)
錯誤就把他們交換過來
'''
a = [11, 2, 33, 1, 5, 88, 3]
def bubbleSort(arr):
n = len(a)
for i in range(n):
for j in range(0, n-i-1):
if a[j] > a[j+1]:
a[j], a[j+1] = a[j+1], a[j]
bubbleSort(a)
print("排序后的數組:", a)
```
</details>
<br />
<details>
<summary>5.3 文本中每行中長度超過3的單詞 </summary>
```
'''
5.3 文本中每行中長度超過3的單詞
在以下文本中找出 每行中長度超過3的單詞:
Call me Ishmael. Some years ago - never mind how long precisely - having
little or no money in my purse, and nothing particular to interest me
on shore, I thought I would sail about a little and see the watery part
of the world. It is a way I have of driving off the spleen, and regulating
the circulation. - Moby Dick
'''
a='''Call me Ishmael. Some years ago - never mind how long precisely - having
little or no money in my purse, and nothing particular to interest me
on shore, I thought I would sail about a little and see the watery part
of the world. It is a way I have of driving off the spleen, and regulating
the circulation. - Moby Dick'''
list1 = [[j for j in i.split(' ') if len(j) > 3] for i in a.split('\n')]
print(list1)
```
</details>
<br />
<details>
<summary>5.4 列表數據寫入txt(open讀寫) </summary>
```
'''
5.4 列表數據寫入txt(open讀寫)
有一個數據list of dict如下
a = [
{"yoyo1": "123456"},
{"yoyo2": "123456"},
{"yoyo3": "123456"},
]
寫入到本地一個txt文件,內容格式如下:
yoyo1,123456
yoyo2,123456
yoyo3,123456
'''
a = [
{"yoyo1": "123456"},
{"yoyo2": "123456"},
{"yoyo3": "123456"},
]
# 方法一
with open("cc.txt", "w") as f:
for i in range(len(a)):
for key, values in a[i].items():
print(key+"," + values + "\r")
f.write(key+"," + values + "\r")
# 方法二
file = open("2.txt", 'w')
for i in range(len(a)):
s = str(a[i]).replace('{', '').replace('}', '').replace("'", '').replace(':', ',') + '\n'
file.write(s)
file.close()
```
</details>
<br />
<details>
<summary>5.5 判斷郵箱程序(正則) </summary>
```
'''
5.5 判斷郵箱程序(正則)
寫一個小程序:控制臺輸入郵箱地址(格式為 username@companyname.com),
程序識別用戶名和公司名后,將用戶名和公司名輸出到控制臺。
要求:
校驗輸入內容是否符合規范(xx@yy.com), 如是進入下一步,如否則拋出提 示"incorrect email format"。注意必須以.com 結尾
可以循環“輸入--輸出判斷結果”這整個過程
按字母 Q(不區分大小寫)退出循環,結束程序
'''
import re
while True:
a = input("請輸入郵箱:")
if a == "q" or a=="Q":
quit()
if re.match("^[0-9a-zA-Z]{1,15}@[0-9a-zA-Z]{1,15}\.com$",a):
username = re.findall("^(.+?)@",a)
print("用戶名:", username[0])
companyname = re.findall("@(.*?)\.com",a)
print("公司名稱:", companyname[0])
else:
print("不合法")
```
</details>
<br />
<details>
<summary>5.6 判斷一個字符串的括號自否閉合(棧) </summary>
```
'''
5.6 判斷一個字符串的括號自否閉合(棧)
判斷一個字符串的括號自否閉合(包括大小中括號)
左括號和右括號必須是一一對應
比如:{[{()}]()} 就是一個閉合的字符串
{[{()}]([)]} 這個里面 ([)] 這種就是不閉合
'''
a = "{[{()}]()}"
b = []
flag = True
for i in a:
if i == "{" or i == "[" or i == "(":
b.append(i)
elif i == "}":
if len(b)==0 or b.pop() != "{":
flag = False
elif i == ")":
if len(b)==0 or b.pop() != "(":
flag = False
elif i == "]":
if len(b)==0 or b.pop() != "[":
flag = False
if len(b) != 0:
flag=False
print(flag)
```
</details>
<br />
<details>
<summary>5.7 計算純數字子串組成的單一數字(子串) </summary>
```
有一個純數字組成的字符串, 返回連續單一數字子串的個數
輸入字符串: “22252”
只含單一數字的子串是
1個字符:2出現4次,5出現1次
2個字符 22 出現2 次
3個字符 222 出現1 次
4個子串 0次
5個字符 0次
總共 4+1+2+1 =8
輸出結果:8
示例:
輸入:22252
輸出: 8
```
</details>
<br />
<details>
<summary>5.8 移除字符串里面的'ab' </summary>
```
```
</details>
<br />
<details>
<summary>5.9 看代碼得結果(join用法) </summary>
```
'''
5.9 看代碼得結果(join用法)
x="abc",y="def",z=["d","e","f"],
分別求出x.join(y) 和x.join(z)返回的結果
'''
x="abc"
y="def"
z=["d","e","f"]
a = x.join(y)
print(a)
b = x.join(z)
print(b)
-----------------
運行結果:
dabceabcf
dabceabcf
```
</details>
<br />
<details>
<summary>5.10 看代碼得結果(類和繼承) </summary>
```
class A(object):
def __init__(self):
self.__Gender()
self.Name()
def __Gender(self):
print("A.__Gender()")
def Name(self):
print("A.Name()")
class B(A):
def __Gender(self):
print("B.__Gender()")
def Name(self):
print("B.Name()")
b = B()
----------------------------
運行結果:
A.__Gender()
B.Name()
```
</details>
<br />
<details>
<summary>5.11 看代碼得結果(閉包) </summary>
```
def fun():
temp = [lambda x: i*x for i in range(4)]
return temp
for everyLambda in fun():
print(everyLambda(2))
---------------
運行結果:
6
6
6
6
```
</details>
<br />
<details>
<summary>5.12 看代碼得結果(列表推導式) </summary>
```
A0 = dict(zip(('a', 'b', 'c', 'd', 'e'), (1, 2, 3, 4, 5)))
A1 = range(10)
A2 = [i for i in A1 if i in A0]
A3 = [A0[s] for s in A0]
A4 = [i for i in A1 if i in A3]
A5 = {i: i*i for i in A1}
A6 = [[i, i*i] for i in A1]
print(A2)
print(A3)
print(A4)
print(A5)
print(A6)
---------------------------------
運行結果:
[]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
[[0, 0], [1, 1], [2, 4], [3, 9], [4, 16], [5, 25], [6, 36], [7, 49], [8, 64], [9, 81]]
```
</details>
<br />
<details>
<summary>5.13 看代碼得結果(函數) </summary>
```
def f(x, l=[]):
for i in range(x):
l.append(i*i)
print(l)
f(2)
f(3, [3, 2, 1])
f(3)
---------------------------------
運行結果:
[0, 1]
[3, 2, 1, 0, 1, 4]
[0, 1, 0, 1, 4]
```
</details>
<br />
<details>
<summary>5.14 看代碼得結果(深拷貝和淺拷貝) </summary>
```
from copy import deepcopy, copy
li = [1, 2, [3, 4]]
li_sliced = li[:]
li_copied = copy(li)
li_deep_copied = deepcopy(li)
li[0] = 888
li[2][0] = 666
print(li_sliced, li_copied, li_deep_copied)
---------------------------------
運行結果:
[1, 2, [666, 4]] [1, 2, [666, 4]] [1, 2, [3, 4]]
```
</details>
<br />
<details>
<summary>5.15 map reduce filter的使用 </summary>
```
'''
5.15 map reduce filter的使用
分別使用map reduce filter 函數完成下面的任務
1.計算 1- 100 的和
2.1-10,對每個數字的平方
3. ["a", "ab", "abc", "bc", "cd"] 輸出含有c字符的元素,返回值是list
'''
```
</details>
<br />
<details>
<summary>5.16 通過切片操作完成以下任務(切片) </summary>
```
'''
5.16 通過切片操作完成以下任務(切片)
有個字符串為"abcdefg.exe" 通過切片完成下面的任務
1.輸出前3個字符
2.輸出后2個字符
3.倒敘輸出
4.間隔1個字符串輸出
'''
str = "abcdefg.exe"
print(str[:3]) # 輸出前3個字符
print(str[-2:]) # 輸出后2個字符
print(str[::-1]) # 倒敘輸出
print(str[::2]) # 間隔1個字符串輸出
```
</details>
<br />
<details>
<summary>5.17 根據列表數字出現次數排序去重(排序) </summary>
```
'''
5.17 根據列表數字出現次數排序去重(排序)
a=[1,2,1,2,2,2,3,4,5,6,56,7,1,3,4]
按列表中數字出現的次數,從高到低排序,并去除重復的
比如2出現了4次,排第一個位置。1出現了3次,于是可以得到:[2, 1, 3, 4, 5, 6, 7, 56]
'''
# 方法一:通過列表
# 取出數字出現的次數放進L中,并降序排序
L = []
a = [1, 2, 1, 2, 2, 2, 3, 4, 5, 6, 56, 7, 1, 3, 4]
for i in a:
L.append(a.count(i))
L = list(set(L))
L.sort(reverse=True)
# 取出次數對應a列表里面的值放進新列表num1中
num1 = []
for m in L:
for n in a:
if m == a.count(n):
num1.append(n)
# 去重
num2 = []
for i in num1:
if i not in num2:
num2.append(i)
print(num2)
# 方法二:通過字典實現
# 將數字和對應重復次數作為key, value放入字典
a = [1, 2, 1, 2, 2, 2, 3, 4, 5, 6, 56, 7, 1, 3, 4]
x = {}
for i in a:
if a.count(i) >= 1:
x[i] = a.count(i)
# 對字典value(重復次數)降序排序,以列表形式返回
x = sorted(x.items(), key=lambda item:item[1], reverse=True)
# 獲取列表中每個元組中的第一個值,即數組中的數字(此時已是按重復次數降序)
num = []
for item in x:
num.append(item[0])
print(num)
```
</details>
<br />
<details>
<summary>5.18 補缺失的代碼-給個路徑查找文件(遞歸) </summary>
```
'''
5.18 補缺失的代碼-給個路徑查找文件(遞歸)
def print_directory_contents(sPath):
"""
這個函數接受文件夾的名稱作為輸入參數,
返回該文件夾中文件的路徑,
以及其包含文件夾中文件的路徑。
"""
'''
def print_directory_contents(sPath):
import os
for sChild in os.listdir(sPath):
sChildPath = os.path.join(sPath, sChild)
if os.path.isdir(sChildPath):
print_directory_contents(sChildPath)
else:
print(sChildPath)
```
</details>
<br />
<details>
<summary>5.19 如何判斷一個字符串有沒有重復字符 </summary>
```
'''
5.19 如何判斷一個字符串有沒有重復字符
判斷一個字符串是否包含重復字符。
例如:“hello”就包含重復字符‘l’,而“world”就不包含重復字符, 有重復打印True, 沒重復打印False
'''
```
</details>
<br />
<details>
<summary>5.20 找出一個字符串中子串不含有重復字符的最長子串(子串) </summary>
```
'''
5.20 找出一個字符串中子串不含有重復字符的最長子串(子串)
給定一個字符串,請你找出其中不含有重復字符的最長子串的長度。
示例1:
輸入:"abcabcbb" 輸出: 3
解釋:因為無重復字符的最長子串是"abc", 所以其長度為3。
示例2:
輸入: "bbbbb"" 輸出: 1
解釋:因為無重復字符的最長子串是"b", 所以其長度為1。
示例3:
輸入: "pwwkew" 輸出: 3
解釋:因為無重復字符的最長子串是"wke"', 所以其長度為3。
請注意,你的答案必須是子串的長度,"pwke"是一個子序列,不是子串。
'''
a = "pwwkew"
b = []
for i in range(1, len(a)+1):
for j in range(len(a)-i+1):
# 生成的組合
new_s = a[j:j+i]
# 判斷是不是重復字串
if len(new_s) == len(set(new_s)):
b.append(new_s)
print(b)
# b中最長的字符
print(max(b, key=lambda x: len(x)))
print("最長字串長度:", len(max(b, key=lambda x: len(x))))
```
</details>
<br />
<details>
<summary>5.21 一個字符串中所有子串是回文的次數(子串) </summary>
```
回文是指正序(從左向右)和倒序(從右向左)讀都是一樣的。
例如:121 ,abcdedcba,123321等都是回文
這種的字符串“ABCABADCSABBAUYIIYU”找出回文出現的次數
子串回文是:'BB', 'II','ABA','ABBA', 'YIIY','UYIIYU' 總共有6個
```
</details>
<br />
<details>
<summary>5.22 找出列表中連續的數字,只取首尾(棧) </summary>
```
找出列表中連續的數字,然后只取首尾
有一個列表[1,2,3,4,8,6,7,11,15]
輸出[(1,4),(6,8)]
```
</details>
<br />
- Linux
- Linux 文件權限概念
- 重點總結
- Linux 文件與目錄管理
- 2.1 文件與目錄管理
- 2.2 文件內容查閱
- 文件與文件系統的壓縮,打包與備份
- 3.1 Linux 系統常見的壓縮指令
- 3.2 打包指令: tar
- vi/vim 程序編輯器
- 4.1 vi 的使用
- 4.2 vim編輯器刪除一行或者多行內容
- 進程管理
- 5.1 常用命令使用技巧
- 5.2 進程管理
- 系統服務 (daemons)
- 6.1 通過 systemctl 管理服務
- Linux 系統目錄結構
- Linux yum命令
- linux系統查看、修改、更新系統時間(自動同步網絡時間)
- top linux下的任務管理器
- Linux基本配置
- CentOS7開啟防火墻
- CentOS 使用yum安裝 pip
- strace 命令
- Linux下設置固定IP地址
- 查看Linux磁盤及內存占用情況
- Mysql
- 關系數據庫概述
- 數據庫技術
- 數據庫基礎語句
- 查詢語句(--重點--)
- 約束
- 嵌套查詢(子查詢)
- 表emp
- MySQL數據庫練習
- 01.MySQL數據庫練習數據
- 02.MySQL數據庫練習題目
- 03.MySQL數據庫練習-答案
- Mysql遠程連接數據庫
- Python
- python基礎
- Python3中字符串、列表、數組的轉換方法
- python字符串
- python安裝、pip基本用法、變量、輸入輸出、流程控制、循環
- 運算符及優先級、數據類型及常用操作、深淺拷貝
- 虛擬環境(virtualenv)
- 網絡編程
- TCP/IP簡介
- TCP編程
- UDP編程
- 進程和線程
- 訪問數據庫
- 使用SQLite
- 使用MySQL
- Web開發
- HTML簡介
- Python之日志處理(logging模塊)
- 函數式編程
- 高階函數
- python報錯解決
- 啟動Python時報“ImportError: No module named site”錯誤
- python實例
- 01- 用python解決數學題
- 02- 冒泡排序
- 03- 郵件發送(smtplib)
- Django
- 01 Web應用
- Django3.2 教程
- Django簡介
- Django環境安裝
- 第一個Django應用
- Part 1:請求與響應
- Part 2:模型與后臺
- Part 3:視圖和模板
- Part 4:表單和類視圖
- Part 5:測試
- Part 6:靜態文件
- Part 7:自定義admin
- 第一章:模型層
- 實戰一:基于Django3.2可重用登錄與注冊系統
- 1. 搭建項目環境
- 2. 設計數據模型
- 3. admin后臺
- 4. url路由和視圖
- 5. 前端頁面設計
- 6. 登錄視圖
- 7. Django表單
- 8. 圖片驗證碼
- 9. session會話
- 10. 注冊視圖
- 實戰二:Django3.2之CMDB資產管理系統
- 1.項目需求分析
- 2.模型設計
- 3.數據收集客戶端
- 4.收集Windows數據
- 5.Linux下收集數據
- 6.新資產待審批區
- 7.審批新資產
- django 快速搭建blog
- imooc-Django全棧項目開發實戰
- redis
- 1.1 Redis簡介
- 1.2 安裝
- 1.3 配置
- 1.4 服務端和客戶端命令
- 1.5 Redis命令
- 1.5.1 Redis命令
- 1.5.2 鍵(Key)
- 1.5.3 字符串(string)
- 1.5.4 哈希(Hash)
- 1.5.5 列表(list)
- 1.5.6 集合(set)
- 1.5.7 有序集合(sorted set)
- Windows
- Win10安裝Ubuntu子系統
- win10遠程桌面身份驗證錯誤,要求的函數不受支持
- hm軟件測試
- 02 linux基本命令
- Linux終端命令格式
- Linux基本命令(一)
- Linux基本命令(二)
- 02 數據庫
- 數據庫簡介
- 基本概念
- Navicat使用
- SQL語言
- 高級
- 03 深入了解軟件測試
- day01
- 04 python基礎
- 語言基礎
- 程序中的變量
- 程序的輸出
- 程序中的運算符
- 數據類型基礎
- 數據序列
- 數據類型分類
- 字符串
- 列表
- 元組
- 字典
- 列表與元組的區別詳解
- 函數
- 案例綜合應用
- 列表推導式
- 名片管理系統
- 文件操作
- 面向對象基礎(一)
- 面向對象基礎(二)
- 異常、模塊
- 05 web自動化測試
- Day01
- Day02
- Day03
- Day04
- Day05
- Day06
- Day07
- Day08
- 06 接口自動化測試
- 軟件測試面試大全2020
- 第一章 測試理論
- 軟件測試面試
- 一、軟件基礎知識
- 二、網絡基礎知識
- 三、數據庫
- SQL學生表 — 1
- SQL學生表 — 2
- SQL查詢 — 3
- SQL經典面試題 — 4
- 四、linux
- a. linux常用命令
- 五、自動化測試
- 自動化測試
- python 筆試題
- selenium面試題
- 如何判斷一個頁面上元素是否存在?
- 如何提高腳本的穩定性?
- 如何定位動態元素?
- 如何通過子元素定位父元素?
- 如果截取某一個元素的圖片,不要截取全部圖片
- 平常遇到過哪些問題?如何解決的
- 一個元素明明定位到了,點擊無效(也沒報錯),如果解決?
- selenium中隱藏元素如何定位?(hidden、display: none)
- 六、接口測試
- 接口測試常規面試題
- 接口自動化面試題
- json和字典dict的區別?
- 測試的數據你放在哪?
- 什么是數據驅動,如何參數化?
- 下個接口請求參數依賴上個接口的返回數據
- 依賴于登錄的接口如何處理?
- 依賴第三方的接口如何處理
- 不可逆的操作,如何處理,比如刪除一個訂單這種接口如何測試
- 接口產生的垃圾數據如何清理
- 一個訂單的幾種狀態如何全部測到,如:未處理,處理中,處理失敗,處理成功
- python如何連接數據庫操作?
- 七、App測試
- 什么是activity?
- Activity生命周期?
- Android四大組件
- app測試和web測試有什么區別?
- android和ios測試區別?
- app出現ANR,是什么原因導致的?
- App出現crash原因有哪些?
- app對于不穩定偶然出現anr和crash時候你是怎么處理的?
- app的日志如何抓取?
- logcat查看日志步驟
- 你平常會看日志嗎, 一般會出現哪些異常
- 抓包工具
- fiddler
- Wireshark
- 安全/滲透測試
- 安全性測試都包含哪些內容?
- 開放性思維題
- 面試題
- 字節測試面試
- 一、計算機網絡
- 二、操作系統
- 三、數據庫
- 四、數據結構與算法
- 五、Python
- 六、Linux
- 七、測試用例
- 八、智力/場景題
- 九、開放性問題
- python3_收集100+練習題(面試題)
- python3_100道題目答案
- 接口測試
- 接口測試實例_01
- python+requests接口自動化測試框架實例詳解
- 性能測試
- 性能測試流程
- 性能測試面試題
- 如何編寫性能測試場景用例
- 性能測試:TPS和QPS的區別
- jmeter
- jmeter安裝配置教程
- Jmeter性能測試 入門
- PyCharm
- 快捷工具
- 1-MeterSphere
- 一、安裝和升級
- 2- MobaXterm 教程
- 3-fiddler抓包
- 4-Xshell
- Xshell的安裝和使用
- Xshell遠程連接失敗怎么解決
- 5-Vmware
- Vmware提示以獨占方式鎖定此配置文件失敗
- Windows10徹底卸載VMWare虛擬機步驟
- VM ware無法關機,虛擬機繁忙
- VMware虛擬機下載與安裝
- 解決VM 與 Device/Credential Guard 不兼容。在禁用 Device/Credential Guard 后,可以運行 VM 的方法
- VMware虛擬機鏡像克隆與導入
- 6-WPS
- 1.WPS文檔里的批注怎么刪除
- 2.wps表格中設置圖表的坐標
- 3. wps快速繪制數學交集圖
- 7-MongoDB
- Win10安裝配置MongoDB
- Navicat 15.x for MongoDB安裝破解教程
- Apache
- apache層的賬戶權限控制,以及apache黑名單白名單過濾功能
- HTTP / HTTPS協議
- HTTP協議詳解
- 代理
- 狀態碼詳解
- HTTPS詳解
- Selenium3+python3
- (A) selenium
- selenium自動化環境搭建(Windows10)
- 火狐firebug和firepath插件安裝方法(最新)
- 元素定位工具和方法
- Selenium3+python3自動化
- 新手學習selenium路線圖---學前篇
- 1-操作瀏覽器基本方法
- 2-八種元素定位方法
- 3-CSS定位語法
- 4-登錄案例
- 5-定位一組元素find_elements
- 6-操作元素(鍵盤和鼠標事件)
- 7-多窗口、句柄(handle)
- 8-iframe
- 9-select下拉框
- 10-alert\confirm\prompt
- 11-JS處理滾動條
- 12-單選框和復選框(radiobox、checkbox)
- 13-js處理日歷控件(修改readonly屬性)
- 14-js處理內嵌div滾動條
- 15-table定位
- 16-js處理多窗口
- 17-文件上傳(send_keys)
- 18-獲取百度輸入聯想詞
- 19-處理瀏覽器彈窗
- 20-獲取元素屬性
- 21-判斷元素存在
- 22-爬頁面源碼(page_source)
- 23-顯式等待(WebDriverWait)
- 24-關于面試的題
- 25-cookie相關操作
- 26-判斷元素(expected_conditions)
- 27-判斷title(title_is)
- 28-元素定位參數化(find_element)
- 29-18種定位方法(find_elements)
- 30- js解決click失效問題
- 31- 判斷彈出框存在(alert_is_present)
- 32- 登錄方法(參數化)
- 33- 判斷文本(text_to_be_present_in_element)
- 34- unittest簡介
- 35- unittest執行順序
- 36- unittest之裝飾器(@classmethod)
- 37- unittest之斷言(assert)
- 38- 捕獲異常(NoSuchElementException)
- 39- 讀取Excel數據(xlrd)
- 40- 數據驅動(ddt)
- 41- 異常后截圖(screenshot)
- 42- jenkins持續集成環境搭建
- 43- Pycharm上python和unittest兩種運行方式
- 44- 定位的坑:class屬性有空格
- 45- 只截某個元素的圖
- 46- unittest多線程執行用例
- 47- unittest多線程生成報告(BeautifulReport)
- 48- 多線程啟動多個不同瀏覽器
- (B) python3+selenium3實現web UI功能自動化測試框架
- (C) selenium3常見報錯處理
- 書籍
- (D)Selenium3自動化測試實戰--基于Python語
- 第4章 WebDriver API
- 4.1 從定位元素開始
- 4.2 控制瀏覽器
- 4.3 WebDriver 中的常用方法
- 4.4 鼠標操作
- 4.5 鍵盤操作
- 4.6 獲得驗證信息
- 4.7 設置元素等待
- 4.8 定位一組元素
- 4.9 多表單切換
- 4.10 多窗口切換
- 4.11 警告框處理
- 4.12 下拉框處理
- 4.13 上傳文件
- 4.14 下載文件
- 4.15 操作cookie
- 4.16 調用JavaScript
- 4.17 處理HTML5視頻播放
- 4.18 滑動解鎖
- 4.19 窗口截圖
- 第5章 自動化測試模型
- 5.3 模塊化與參數化
- 5.4 讀取數據文件
- 第6章 unittest單元測試框架
- 6.1 認識unittest