Python4.22每周一练

一、列表问题

1.列表拷贝

# 1.深浅拷贝
"""
=:怎么都会改
列表.copy()和copy.copy()：只有修改一维列表中元素的时候，一个更改，另外一个不受影响
copy.deepcopy()：怎么都不会改

浅拷贝：只拷贝了列表的最外层
深拷贝：不管嵌套几层，都会被拷贝
"""
a = [1,2,3]
b = [4,5]
c = [a,b]   # c = [[1,2,3],[4,5]]
d = c       # d = [[1,2,3],[4,5]]
e = c.copy()  # e  = [[1,2,3],[4,5]]
a.append(20)
# 问：d和e的值分别为多少
print(c is d)   # True
print(c is e)   # False

print(c)   # c = [[1,2,3,20],[4,5]]
print(d)   # d = [[1,2,3,20],[4,5]]
print(e)   # e = [[1,2,3,20],[4,5]]

import copy
a  = [1,2,['a','b']]
b = a
c = copy.deepcopy(a)
a[-1].append(3)
# 问：b和c的值分别为多少
print(a)  # a = [1,2,['a','b',3]]
print(b)  # b = [1,2,['a','b',3]]
print(c)  # c = [1,2,['a','b']]

a  = [1,2,['a','b']]
b = a
c = copy.deepcopy(a)
a.append(3)
# 问：b和c的值分别为多少
print(a)  # a = [1,2,['a','b'],3]
print(b)  # b = [1,2,['a','b'],3]
print(c)  # c = [1,2,['a','b']]

2.嵌套列表

 

# 2.嵌套列表
list1 = [[23,54],[3,4,5]]
# 元素的访问
sublist1 = list1[0]
sublist2 = list1[1]
print(sublist1)
print(sublist2)

num1 = sublist1[0]
num2 = sublist2[2]
print(num1,num2)

# 直接访问
print(list1[0][1])

# 多维列表元素的遍历
for sublist in list1:
 print(sublist)
 for num in sublist:
     print(num)

for i in range(len(list1)):
 print(list1[i])
 for j in range(len(list1[i])):
     print(list1[i][j])

for i,sublist in enumerate(list1):
 for j,num in enumerate(sublist):
     print(num)

 

二、简单算法

 

 

1.简述冒泡排序原理

1. 比较相邻的两个元素。如果第一个比第二个大则交换他们的位置(升序排列，降序则反过来)。

2. 从列表的开始一直到结尾，依次对每一对相邻元素都进行比较。这样，值最大的元素就通过交换“冒泡”到了列表的结尾，完成第一轮“冒泡”。

3. 重复上一步，继续从列表开头依次对相邻元素进行比较。已经“冒泡”出来的元素不用比较(一直比较到结尾也可以，已经“冒泡”到后面的元素即使比较也不需要交换，不比较可以减少步骤)。

4. 继续从列表开始进行比较，每轮比较会有一个元素“冒泡”成功。每轮需要比较的元素个数会递减，一直到只剩一个元素没有“冒泡”时(没有任何一对元素需要比较)，则列表排序完成。

 

 

2.使用冒泡法对列表[10,17,50,7,30,24,27,45,15,5,36,21]分别进行升序（降序）

 

list1 = [10,17,50,7,30,24,27,45,15,5,36,21]

# 冒泡升序排序

# 外层循环：控制比较的轮数
for i in range(len(list1) - 1):
    # 内层循环：控制的是每一轮比较的次数，以及参与比较的下标
    for j in range(len(list1) - 1 - i):
        # 比较：如果符合条件则交换位置
        # 如果下标小的元素  > 下标大的元素，则交换位置（<为降序）
        if list1[j] > list1[j + 1]:
            list1[j],list1[j + 1] = list1[j + 1],list1[j]
print(list1)

 

3.简述选择排序的原理：

选择排序的原理如下：

1. 从待排序列表中找到最小的元素(升序排列，降序排列则找最大的元素)，存放到列表的起始位置，作为已排序的序列。

2. 继续从未排序序列中找到最小的元素，存放到已排序序列的末尾(同时也是未排序序列的起始位置)。

3. 重复第2步，直到所有元素都已经存放到了已排序序列，则列表排序完成。

 

4. [10,17,50,7,30,24,27,45,15,5,36,21] 进行升序排列 (选择排序法)

 

list1 =  [10,17,50,7,30,24,27,45,15,5,36,21]

# 选择升序排序

# 外层循环：控制比较的轮数
for i in range(len(list1) - 1):
    # 内层循环：控制的是每一轮比较的次数，以及参与比较的下标
    for j in range(i + 1,len(list1)):
        # 比较，如果符合条件，则交换位置
        if list1[i] > list1[j]:
            list1[i],list1[j] = list1[j],list1[i]
print(list1)

 

4.顺序查找

查找思路：遍历指定列表，把要查找的数据依次和列表中的每一位元素进行比较

 

# 顺序查找不是算法，只是最简单的用来查询元素的方式，主要核心思想是遍历列表
# 查找所有指定的元素的位置
# list1 = [34,347,3,73,74,34,87,9,10,9,9,239]
# key = 9
# for i in range(len(list1)):
#     if list1[i] == key:
#         print("待查找元素%s在列表中存在，对应的索引为：%d" % (key,i))

# 模拟index功能，只查找第一次出现的元素的位置
list1 = [34,347,3,73,74,34,87,9,10,9,9,239]
key = 9
for i in range(len(list1)):
 if list1[i] == key:
     print("待查找元素%s在列表中存在，对应的索引为：%d" % (key,i))
     break
else:
 print("待查找元素%s在列表中不存在" % (key))

# 练习：自定义一个数字列表，求列表中第二大数的下标
list1 = [34,347,3,73,74,347,347,34,87,9,347,347,10,9,9,239]
# a.备份列表
new_list = list1.copy()
# b.对备份列表进行排序
for i in range(len(new_list) - 1):
 for j in range(len(new_list) - 1 - i):
     if new_list[j] > new_list[j + 1]:
         new_list[j],new_list[j + 1] = new_list[j + 1],new_list[j]
print(new_list)
# c.获取最大值
max_value = new_list[-1]
# d.统计最大值出现的次数
max_count = new_list.count(max_value)
# e.获取第二大值
second_value = new_list[-(max_count + 1)]
# f.回到原列表中进行顺序查找
for i in range(len(list1)):
 if list1[i] == second_value:
     print("第二大值为：%d,在列表中的位置为：%d" % (second_value,i))

aList=[1,2,3,4,5,6,3,8,9]
5 in aList             #查找5是否在列表中 
aList.index(5)         #返回第一个数据5的下标
aList.index(5,4,10)    #返回从下标4到10(不包含) 查找数据5
aList.count(5)         #返回数据5的个数

 

 

5.简述二分法查找原理

 

查找思路：前提列表是有序（升序或者降序）的，通过折半来缩小查找范围，提高查找效率

在升序的前提下， 将待查找的元素与中间下标对应的元素比较，如果大于中间下标对应的元素，则去右半部分查找
 

6.使用二分法查找 [34,55,67,88,99,100,888,9999] 元素99的位置

 

# 已知列表list1 = [34,55,67,88,99,100],使用二分法查找67在列表中的位置

# 注意：二分法的前提：列表必须是有序的
list1 = [34,55,67,88,99,100,888,9999]
list1.sort()

key = 99

# 定义最大下标和最小下标
left = 0
right = len(list1) - 1

# 循环计算中间的下标，并且通过比较数的大小，重置left和right的值
while left <= right:
    # 计算中间的下标
    middle = (left + right) // 2
    # 用待查找元素和中间下标对应的元素进行比较
    # 以升序为例
    if  key > list1[middle]:
        # 重置left的值
        left = middle + 1
    elif key < list1[middle]:
        # 重置right的值
        right = middle - 1
    else:
        # 找到了
        print("待查找元素%d在列表中的位置为：%d" % (key,middle))
        # 如果拿到结果，则可以提前结束循环
        break
else:
    print("待查找元素%d在列表中不存在" % (key))