零py-(ep-13)

Nicole37

列表4：

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

a = ["today","is","friday"]
b = ["let","us","have","fun"]
a+b
['today', 'is', 'friday', 'let', 'us', 'have', 'fun']
a*3
['today', 'is', 'friday', 'today', 'is', 'friday', 'today', 'is', 'friday']

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

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

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

for i in c:
    for j in i:
        print(j)

        
1
2
3
5
6
9

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

    
1 2 3 
5 6 9 

用下标索引来访问：

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

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

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

    
e
[[6, 6, 6], [6, 6, 6], [6, 6, 6]]

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

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

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

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

a =[0,0,0]
for i in range(3):
    a[i] = [8]*3

    
a
[[8, 8, 8], [8, 8, 8], [8, 8, 8]]
b = [[8]*3]*3 #b这种构造方法 只是对同一个列表[8,8,8]进行3次调用,并没有开辟3个内存空间存放每个元素
b
[[8, 8, 8], [8, 8, 8], [8, 8, 8]]
b[0] is b[1]
True
b[0] is b[2] #判断b的两个元素是否内存位置相同
True
a[0] is a[2] #由于a是正常构造嵌套列表，其两个元素列表所占的位置是不同的
False

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

a = [0]*3
b = [0]*3
for i in range(3):
    b[i] = [8]*3
    for j in range(3):
        a[j] = [b[i]]*3

        
a
[[[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、根据内存关系画图（我）：

x = [[0]*3]*3
x
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

y = [0]*3
for i in range(3):
    y[i] = [0]*3 
y
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

z = [0]*3
p = [0]*2
for i in range(2):
    p[i] = [0]*2
    for j in range(3):
        z[j] = [p[i]]*3  
z
[[[0, 0], [0, 0], [0, 0]], [[0, 0], [0, 0], [0, 0]], [[0, 0], [0, 0], [0, 0]]]

z = [0] * 3  #方法二
for i in range(3):
    z[i] = [0] * 3
    for j in range(3):
        z[i][j] = [0] * 2

3、

 a = 250
 b = 250
 a is b
True
a = 1000
b = 1000
a is b
False

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

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

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

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

不二如是

此图出自？：

Nicole37

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

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