python --- 难点重点总结

生成式子

• 列表生成式

 

• 字典生成式

 

深浅拷贝

 1 list0 = [12,24,34,32,[64,23]]
 2 
 3 # 浅拷贝：浅拷贝只是将最外层容器拷贝一份放在堆里面，内层的容器不会被拷贝还是使用原来的地址
 4 list1 = list0.copy()
 5 print(id(list0))  # 结果地址：4517928904
 6 print(id(list1))  # 结果地址：4518644936
 7 
 8 print(id(list0[4])) # 结果：4545167240
 9 print(id(list1[4])) # 结果：4545167240
10 
11 # 深浅拷贝对应的模块
12 import copy
13 
14 # 浅拷贝。模块中的浅拷贝就相当于列表中自带的copy
15 list2 = copy.copy(list0)
16 print(id(list2))
17 print(id(list0))
18 
19 print(id(list0[4]))
20 print(id(list2[4]))
21 
22 # 深拷贝。不仅外层地址拷贝一份新的，内层也会拷贝一份新的出来
23 list3 = copy.deepcopy(list0)
24 print(id(list0)) # 结果：4513963976
25 print(id(list3)) # 结果：4519921672
26 
27 print(id(list0[4])) # 结果：4513963912
28 print(id(list3[4])) # 结果：4519922696
29 
30 
31 """
32 内容不可变对象没有深浅拷贝一说。地址是不变的
33 """
34 a = 10
35 b = copy.copy(a)
36 c = copy.deepcopy(a)
37 print(id(a)) # 4460273008
38 print(id(b)) # 4460273008
39 print(id(c)) # 4460273008 

排序算法

•  冒泡排序

　　 规则： 每一次遍历比较列表中的元素时，都是从左向右两两进行比较。

      　　　 每一次遍历比较之后都会得到最值，下一次遍历，最值元素不会再参与比较。        

      　　　 每一次遍历都会少一个元素。每次遍历都是从零元素开始。

　 　遍历循环：需要双层遍历

    　　　　内层遍历作用：控制遍历列表，取元素进行比较。控制列表元素比较次数。

    　　　　外层遍历作用：到底经历了多少次遍历，完成了排序效果。控制遍历的次数

    　　　　遍历的次数为列表长度-1， 每次遍历比较的次数为：列表长度 - 第几次遍历

 1 """
 2 第一次遍历取了7个元素，意味着该遍历比较了7次
 3 第二次遍历取了6个元素，意味着该遍历比较了6次
 4 第三次遍历取了5个元素，意味着该遍历比较了5次
 5 ......
 6 列表的长度 = 第几次遍历 + 所取元素比较次数
 7 """
 8 list0 =[23,45,67,89,43,658,24,25,]
 9 for out in range(1,len(list0)):
10     for inner in range(len(list0)-out):
11         if list0[inner]<list0[inner+1]:
12             list0[inner],list0[inner+1] = list0[inner+1],list0[inner]
13 print(list0)

•  选择排序 

　　规则：每次排序遍历都找对应的最小值，再与指定的位置元素进行交换。

　 　　　　第一次遍历：假设第一个元素最小的，与之后的每一个元素进行比较，找到最小值后与第一个元素进行交换

　　　　　　　　　　　（或者假设脚标为0的元素是最小的，然后遍历找到真正最小值对应的脚标）

    　　　　第二次遍历：假设第二个元素是剩余元素最小的值，与之后的每一个元素比较，找到这其中最小的再与第二个元素位置交换

    　　　　　　　　　　遍历列表的次数：列表长度 - 1

 

    　　　　第一次遍历的时候，遍历的起始脚标是0；第二次遍历的时候，遍历的起始脚标是1，….可以通过最值索引，然后再交换

 1 """
 2 遍历列表的次数
 3     第一次遍历，遍历的起始脚标是0
 4     第二次遍历，遍历的起始脚标是1
 5     第三次遍历，遍历的起始脚标是2
 6     .......
 7     遍历的次数 = len（list0）- 1
 8     遍历的起始脚标 = 遍历的次数 - 1
 9 """
10 list0 =[34,56,3,66,32,78]
11 for out in range(1,len(list0)):
12     for inner in range(out-1,len(list0)):
13         if list0[out-1]<list0[inner]:
14             list0[inner],list0[out-1] = list0[out-1],list0[inner]
15 print(list0)

•  插入排序

　　 反向冒泡                

　　 规则：第一次取　　脚标为1的元素 与之前的元素两两进行比较

     　　　 第二次取　　脚标为2的元素 与之前的元素两两进行比较

　　 好处：排序过程中会出现部分有序的情况，可以终止排序

　　 规律：遍历的次数：len(str)-1

     　　　 第一次遍历的起始值是1，

    　　　  第二次遍历的次数是2 。。。

1 List0 = [32,45,67,4,734,78,]
2 for out in range(1,len(list0)):
3     for inner in range（out，0，-1）：
4         if list0[inner]< list[inner-1]:
5             交换位置
6         else：
7             break

查找算法

• 普通查找

 

• 二分查找

 

函数类别

 

 

递归调用

 

 

单例模式

 

---

 

---

 

闭包

 

装饰器

 

生成器

 

迭代器

 

 

 

转载于:https://www.cnblogs.com/TMMM/p/11422042.html