Python第二周 学习笔记（3）

1.运用数组实现求10万以内质数：

prime = [2]
for i in range(3,100000,2):
    flag = False
    up = int(i**0.5)+1
    for j in prime:
        if i % j == 0:
            flag = False
            break
        if j >= up:
            flag = True
            break    
    if flag:
        prime.append(i)
print(len(prime))

2.杨辉三角：

方法一（1）迭代后首尾加元素1：

n=6
pre=[[1]]
for i in range(n):
    line=pre[i]
    temp=[1]
    for j in range(i):
        temp.append(line[j]+line[j+1])
    temp.append(1)
    pre.append(temp)
print(pre)

方法一（2）：

n = 6
pre = [1]
for i in range(n):
    temp = [1]
    for j in range(i):
        temp.append(pre[j] + pre[j + 1])
    temp.append(1)
    print(pre)
    pre = temp

方法二 列表前后或后补元素0迭代：

n=6
pre=[1]
for i in range(1,n):
    pre.append(0)
    newline=[]
    for j in range(i+1):
        var=pre[j-1]+pre[j]
        newline.append(var)
    print(newline)
    pre=newline

方法三（1）提前创建好宽度合适、充满1的列表，将计算的结果替换列表中对应位置的数，

采用对称性一次循环将对称的两个元素一并替换：

n=6
triangle=[]
for i in range(n):
    temp=[1]*(i+1)
    for j in range(1,i//2+1):
        var=triangle[j-1]+triangle[j]
        temp[j]=var
        if i!=2*j:
            temp[-j-1]=var
    triangle=temp
    print(temp)

方法三（2）：

n = 6
triangle = []
for i in range(n):
    temp = [1] * (i + 1)
    triangle.append(temp)
    for j in range(1,i // 2 + 1):
        var = triangle[i - 1][j - 1] + triangle[i - 1][j]
        temp[j] = var
        if i != 2 * j:
            temp[- j - 1] = var
    print(temp)
    pre = temp

方法四 只开辟最大长度的一个充满1的列表，加入一个临时变量存储替换的元素，

参与下一次计算，采用对称性，注意更改对称元素时，其索引值需加入一个偏移量，

输入时对列表切片：

n = 6
triangle = [1] * n
for i in range(n):
    temp = 1
    for j in range(1,i // 2 + 1):
        var = temp + triangle[j]
        temp = triangle[j]
        triangle[j] = var
        if i != j * 2:
            triangle[- j - (n - i)] = var
    print(triangle[: i + 1])

3.冒泡法排序

• 两两比较大小，交换位置。如同水泡咕嘟咕嘟往上冒
• n个数从左至右，编号从0开始到n-1，索引0和1的值比较，如果索引0大，则交换两者位置，如
  果索引1大，则不交换。继续比较索引1和2的值，将大值放在右侧。直至n-2和n-1比较完，第
  一轮比较完成。第二轮从索引0比较到n-2，因为最右侧n-1位置上已经是最大值了。依次类推，
  每一轮都会减少最右侧的不参与比较，直至剩下最后2个数比较。
• 时间复杂度O(n**2)

方法一：

lst=[9,8,7,6,5,4,3,2,1]
cnt=0
cnt_swap=0
for i in range(len(lst)-1):
    for j in range(len(lst)-i-1):
        cnt+=1
        if lst[j]>lst[j+1]:
            lst[j],lst[j+1] = lst[j+1],lst[j]
            cnt_swap+=1
print(lst,cnt,cnt_swap)

方法二(优化)：

优化点:如果当一个内循环结束后，并没有发生元素交换的操作，则剩下的元素已经是顺序的了，无需再往下执行

#lst = [9,8,7,6,5,4,3,2,1]
#lst = [1,2,3,4,6,5,7,8,9]
lst = [2,1,3,4,5,6,7,8,9]
cnt = 0
cnt_swap = 0
for i in range(len(lst) - 1):
    flag = False 
    for j in range(len(lst) - i - 1):
        cnt += 1
        if lst[j] > lst[j + 1]:
            lst[j],lst[j + 1] = lst[j + 1],lst[j]
            flag = True
            cnt_swap += 1
    if not flag:
        break
print(lst,cnt,cnt_swap)

4.从lst = [1,(2,3,4),5]中，提取4出来

lst = [1, (2, 3, 4), 5]
_, (*_, a), _ = lst
print(a)

5.环境变量JAVA_HOME=/usr/bin，返回变量名和路径

str = 'JAVA_HOME=usr/bin'
name, path = str.split('=')
print(name, path)

6.你的好友A、B、C，他的好友C、B、D，求共同好友

a = {'A', 'B', 'C'}
b = {'C', 'B', 'D'}
print(a & b)

7.XXX与群里其他人都不是微信朋友关系

XXX_friends = {'A', 'B', 'C'}
b = {'E', 'F', 'D'}
if not XXX_friends & b:
    print('Warning! :XXX')

8.有一个api，要求权限同时具备A、B、C才能访问，用户权限是B、C、D，判断用户是否能够访

问该API

sys_auth = {'A', 'B', 'C'}
user_auth = {'B', 'C', 'D'}
if sys_auth <= user_auth : #sys_auth是B的子集
    print('Pass!')
else :
    print('Insuffitient auth!') 

9.有一个API，要求权限具备A、B、C任意一项就可访问，用户权限是B、C、D，判断用户是否能

够访问该API

sys_auth = {'A', 'B', 'C'}
user_auth = {'B', 'C', 'D'}
if sys_auth & user_auth:
    print('Pass!')
else :
    print('Insuffitient auth!')

10.一个总任务列表，存储所有任务。一个完成的任务列表。找出为未完成的任务

mission = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'}
completed_mission = {'C', 'E', 'G'}
print(mission - completed_mission)

11.随机产生2组各10个数字的列表，如下要求：

• 每个数字取值范围[10,20]

• 统计20个数字中，一共有多少个不同的数字？

• 2组中，不重复的数字有几个？分别是什么？

• 2组中，重复的数字有几个？分别是什么？

  from random import randint
  a = []
  b = []
  for i in range(20):
  if i > 9:
      a.append(randint(10, 20))
  else:
      b.append(randint(10, 20))
  print(a, b)
  set_a = set(a)
  set_b = set(b)
  print('set_uNIOn: ', set_a | set_b)
  print('set_minus: ', set_a & set_b)
  print('set_intersect: ', set_a ^ set_b)

12.求杨辉三角的第m行第k个元素:

方法一：

a = int(input('a')) - 1
b = int(input('b'))
mul_a = 1
mul_c = 1
for i in range(b - 1):
    mul_a *= a
    a -= 1
for j in range(1, b):
    mul_c *= j
print(mul_a, mul_c, mul_a / mul_c)

方法二：

n = int(input('>>>')) - 1
m = int(input('>>>')) - 1
r = n - m
l=[]
mul=1
for i in range(1, n + 1):
    mul *= i
    if i == m:
        l.append(mul)
    if i == r:
        l.append(mul)
    if i == n:
        l.append(mul)
print(l[2] // (l[0] * l[1]))

13.给定一个矩阵，求其转置矩阵：

方法一：

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
new_matrix = []
for i in range(len(matrix[0])):
    temp = []
    for j in range(len(matrix)):
        temp.append(matrix[j][i])
    new_matrix.append(temp)
print(new_matrix)

方法二：

matrix = [[1, 2, 3], [4, 5, 6]]
tm = []
for row in matrix:
    for i ,col in enumerate(row):
        if len(tm) < i + 1:
            tm.append([])
        tm[i].append(col)
print(tm)

方法三：

对于大矩阵速度更快

matrix = [[1, 2, 3], [4, 5, 6]]
tm = [[0 for col in range(len(matrix))] for row in range(len(matrix[0]))]
for i,row in enumerate(tm):
    for j, col in enumerate(row):
        tm[i][j] = matrix[j][i]
print(tm)

14.随机产生10个数字

• 要求

  • 每个数字取值范围[1,20]

  • 统计重复的数字有几个？分别是什么？

  • 统计不重复的数字有几个？分别是什么？

    方法一：

import random
lst = []
rep_lst = []
uniq_lst = []
for i in range(10):
    temp = random.randint(1, 20)
    if temp in lst and temp not in rep_lst:
        rep_lst.append(temp)
    lst.append(temp)
for j in lst:
    if j not in rep_lst:
        uniq_lst.append(j)
print(lst)
print(len(rep_lst), ': ', rep_lst)
print(len(uniq_lst), ': ', uniq_lst)

方法二：

import random
nums = []
for _ in range(10):
    nums.append(random.randrange(21))
print(nums)
length=len(nums)
samenums = []
diffnums = []
states=[0] * length
for i in range(length):
    flag = False
    if states[i] == 1:
        continue
    for j in range(i + 1, length):
        if states[j] == 1:
            continue
        if nums[i] == nums[j]:
            flag = True
            states[j] = 1
    if flag:
        samenums.append(nums[i])
        states[i] = 1
    else:
        diffnums.append(nums[i])
print('{}\n{}'.fORMat(samenums, diffnums))