零py-(ep-13)

Nicole37

列表4：

加法：将两个列表进行拼接
乘法：将列表中的元素重复x次

1. a = ["today","is","friday"]
   
2. b = ["let","us","have","fun"]
   
3. a+b
   
4. ['today', 'is', 'friday', 'let', 'us', 'have', 'fun']
   
5. a*3
   
6. ['today', 'is', 'friday', 'today', 'is', 'friday', 'today', 'is', 'friday']

复制代码

嵌套列表（二维列表）：在列表中嵌套列表；可用于“举证”

1. c = [[1,2,3],[5,6,9]]
   
2. c
   
3. [[1, 2, 3], [5, 6, 9]]

复制代码

访问嵌套列表：
用嵌套循环来访问:

1. for i in c:
   
2.     for j in i:
   
3.         print(j)
   
4. 
   
5.         
   
6. 1
   
7. 2
   
8. 3
   
9. 5
   
10. 6
    
11. 9

复制代码

1. for i in c:
   
2.     for j in i:
   
3.         print(j,end = ' ') #print语句默认是自动换行的，加了end以后，输出的数据不会自动换行，而是取决于end里面的空格数
   
4.     print() #遍历一遍j以后，换行
   
5. 
   
6.    
   
7. 1 2 3
   
8. 5 6 9

复制代码

用下标索引来访问：

1. c[0][2] #第一个下标表示取出c的下标为0的元素为[1,2,3],第二个下标表示取出[1,2,3]中的下标为2的元素
   
2. 3

复制代码

用循环语句创建并初始化循环列表：

1. e = [0,2,5] #想创建一个3个元素的嵌套列表，先将列表初始化3个元素
   
2. for i in range(3): #循环3次，每次都让e的元素为一个列表
   
3.     e[i] = [6]*3
   
4. 
   
5.    
   
6. e
   
7. [[6, 6, 6], [6, 6, 6], [6, 6, 6]]

复制代码

注意：python在idle中只能一句一句编译，故不能将所有段落直接复制，一句一句复制/在文件里运行

is运算符：同一性运算符，用于检验两个变量是否指向同一个运算符

1. x = "yuanjiyunjiao"
   
2. y = "yuanjiyunjiao"
   
3. x is y #is用来比较两个变量是否指向同一个运算符 字符串在python的内存空间是固定的，只开辟一个空间存放该字符串(仅限于英文字母)
   
4. True
   
5. p = [1,2,3]
   
6. q = [4,5,6]
   
7. p is q #列表在python中占据不同的地址内存，即使列表的内容一样，所占的位置也是不同的
   
8. False

复制代码

注意：用循环嵌套和乘法 两种方法所构造出的嵌套列表是不同的

1. a =[0,0,0]
   
2. for i in range(3):
   
3.     a[i] = [8]*3
   
4. 
   
5.    
   
6. a
   
7. [[8, 8, 8], [8, 8, 8], [8, 8, 8]]
   
8. b = [[8]*3]*3 #b这种构造方法 只是对同一个列表[8,8,8]进行3次调用,并没有开辟3个内存空间存放每个元素
   
9. b
   
10. [[8, 8, 8], [8, 8, 8], [8, 8, 8]]
    
11. b[0] is b[1]
    
12. True
    
13. b[0] is b[2] #判断b的两个元素是否内存位置相同
    
14. True
    
15. a[0] is a[2] #由于a是正常构造嵌套列表，其两个元素列表所占的位置是不同的
    
16. False

复制代码

作业：
1、建立三维列表（我）：

1. a = [0]*3
   
2. b = [0]*3
   
3. for i in range(3):
   
4.     b[i] = [8]*3
   
5.     for j in range(3):
   
6.         a[j] = [b[i]]*3
   
7. 
   
8.         
   
9. a
   
10. [[[8, 8, 8], [8, 8, 8], [8, 8, 8]], [[8, 8, 8], [8, 8, 8], [8, 8, 8]], [[8, 8, 8], [8, 8, 8], [8, 8, 8]]]
    

复制代码

2、根据内存关系画图（我）：

1. x = [[0]*3]*3
   
2. x
   
3. [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
   
4. 
   
5. y = [0]*3
   
6. for i in range(3):
   
7.     y[i] = [0]*3
   
8. y
   
9. [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
   
10. 
    
11. z = [0]*3
    
12. p = [0]*2
    
13. for i in range(2):
    
14.     p[i] = [0]*2
    
15.     for j in range(3):
    
16.         z[j] = [p[i]]*3  
    
17. z
    
18. [[[0, 0], [0, 0], [0, 0]], [[0, 0], [0, 0], [0, 0]], [[0, 0], [0, 0], [0, 0]]]
    
19. 
    
20. z = [0] * 3  #方法二
    
21. for i in range(3):
    
22.     z[i] = [0] * 3
    
23.     for j in range(3):
    
24.         z[i][j] = [0] * 2

复制代码

3、

1. a = 250
   
2. b = 250
   
3. a is b
   
4. True
   
5. a = 1000
   
6. b = 1000
   
7. a is b
   
8. False

复制代码

出于性能优化方面的考虑，Python 在内部为 -5~256 范围内的整数维护了一个数组，起到缓存的作用,每次你试图创建一个 -5~256 范围内的整数时，Python 都会从这个数组中返回相对应的引用，而不是重新开辟一块新的内存空间存放。如果超过了 -5~256 这个范围（大家可以自己动手测试一下），比如 1000，那么 Python 会为两个 1000 单独开辟两块不同的内存区域，因此 a is b 的结果为 False

4、利用“摩尔投票法”来找出占比数量最多的两个元素（注意：这两个元素的数量都需要超过总数的三分之一）

1. nums = [1, 1, 2, 1, 3, 2, 3, 2]
   
2.    
   
3. major1 = major2 = nums[0] #分别给第一和第二的两个初始化为nums[0]
   
4. count1 = count2 = 0 #初始化他们的计数值都为0
   
5.    
   
6. # 对抗阶段
   
7. for each in nums:   
   
8.     if major1 == each: #并列判断两个major，优先判断major1，如果遍历的元素等于major则，count值加一，之后continue退出后面的左右步骤，为了避免影响到major2,
   
9.         count1 += 1
   
10.         continue
    
11.    
    
12.     if major2 == each:
    
13.         count2 += 1
    
14.         continue
    
15.    
    
16.     if count1 == 0: #当发现count1的值为0，即加加减减抵消掉了，则更新major1的值为当前遍历的元素值，并赋其初始计数值为1
    
17.         major1 = each
    
18.         count1 = 1
    
19.         continue
    
20.    
    
21.     if count2 == 0: #当发现count2的值为0，即加加减减抵消掉了，或者是each既不是major1也不是major2,并且此时major的计数值不为零，major1在正常迭代，则major2需要换新值，并赋其初始计数值为1
    
22.         major2 = each
    
23.         count2 = 1
    
24.         continue
    
25.    
    
26.     count1 -= 1 #当上述条件均不符合，即major1和major2都在正常的判断加加减减中，则each不等于二者，所以计数值减一
    
27.     count2 -= 1
    
28.    
    
29. # 统计阶段
    
30. if nums.count(major1) > len(nums) / 3:
    
31.     print(major1)
    
32. if nums.count(major2) > len(nums) / 3:
    
33.     print(major2)
    

复制代码

不理解的时候画图，模拟计算机的操作流程

不二如是

此图出自？：

Nicole37

不二如是 发表于 2023-8-7 16:12
此图出自？：

不是这个视频，但是是小师妹一个系列滴