[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