pyhon基础之逻辑运算训练 列表详解 for循环

1.逻辑运算练兵

#逻辑表达式运算
1. True and True or True 		            	True
2. True and True or False                       True
3. False and True or True                       True
4. False and True or False                      False
5. False and False or True                      True
6. 3 and 5                                       5
7. 0 and "abc"                                   0
8. "aaa"  or "bbb"                             “aaa”
9. True  and 0                                   0
10. 0.0 or False                                False

#[problem]输出9行内容，第1行输出1，第2行输出12，第3行输出123，
#以此类推，第9行输出123456789
#法一
num1 = 1
while num1 <= 10:
    num2 = 1
    while num2 < num1:
        print(num2,end="")
        num2 += 1
    print()
    num1 += 1
  #法 二 
befor = ""
for i in range(1,9+1):
   result = str(befor)+str(i)
   print(str(result))
   befor = result
   #法三
  i = 1
result = 0
for i in range(0,9+1,1):
    result = result*10+i
    print(result)

2.1初识列表

• 列表相当于是一个容器，可以同时存储多种类型的数据
• 列表是一个有序的，可变的，可以存储重复元素的集合
  • 说明：有序指的就是有顺序【数据的存放的顺序和底层存储的顺序是相同的】

2.2列表定义

语法：列表名 = [数据1,数据2,数据3…]

• 列表名其实就是一个变量名【标识符】，注意：尽量不要直接使用list【因为系统有一个功能list(x)，涉及到重写覆盖的问题，导致系统原有的功能失效】
• []是列表特有的表示方式
• 数据1,数据2,数据3被称为元素【element】
• 列表中的元素会被自动编号，从0开始，该编号被称为索引，下标或者角标,这是列表有序的体现
• 索引的取值范围：0 ~ (元素个数 - 1)
  -元素个数 (也就是第一个元素) ~ -1（也就是最后一个元素）【负索引】

2.3列表的工作原理

"""
列表的工作原理：只要将要存储的数据存放到列表中，不需要考虑列表
的容量，如果在数据量很大的情况下，列表底层会进行自动扩容，因为
列表的底层维护了一个栈（stack）{此处的 栈：可以理解为一个开口
向上的容器（特点：先进后出）；队列：可以理解尉一个水平放置的容
器（先进先出）}（此处的栈和空间理解为一种数据结构）【所以你只要
管将数据放进去就行】


"""
#注意：列表中实际上存储的是元素的地址，而非元素本身
#列表中元素的访问都是通过索引访问的，语法：列表名[索引]

2.4列表的操作

#   一.列表的访问

#1.1获取元素
#注意：一定要在索引的范围内访问元素，否则会造成索引越界
#索引的取值范围：0 ~ 个数 - 1        - 个数  ~  -1
list1 = [10,20,30]
print(list1[1])
num1 = list1[1]
print(num1)

print(list1[2])
print(list1[-1])

print(list1[0])
print(list1[-3])
#print(list1[3])  #IndexError索引越界: list index索引 out of range
#print(list1[-4])

#1.2.修改
#注意：列表是一种可变的数据类型，可以增加，删除或者修改元素
print(list1)
list1[1] = 100
print(list1)

list1 = [1,2,3]
list2 = [5,6,7]
# 2.1.列表组合：+
print(list1 + list2)
print(list1)
print(list2)

#2. 2.列表元素的重复：*
print(list1 * 3)

# 2.3.成员运算符：in和 not in
print(1 in list1)  # True
print(20 in list1)  # False

print(1 not in list1)  # False
print(20 not in list1)  # True
# 工作原理：将指定数据和列表中的元素进行依次比对，如果相等则表示存在，否则不存在

#  切片
"""

【problem】什么是列表切片？
    通过指定的区间和指定的步长，获取指定列表中的指定元素，
    生成一个新的列表

注意：切片可以发生在列表，元组和字符串中，使用方式完全相同

语法：列表[start:end:step]
说明：
     a.列表切片的结果还是一个列表
     b.start：开始索引，可以省略，默认为第0个元素
       end；结束索引，可以省略，默认为最后一个元素
       step:步长，可以省略，默认为1
     c.切片的本质：根据指定的索引区间获取原列表中的指定元素，然
       后生成一个新的子列表
     d.索引的取值：[start,end,step都可以是正数，负数]
       -8  -7  -6  -5   -4   -3   -2    -1   0    1    2    
       3    4    5    6   7   8
     e.当start和end被指定，取值方式：【前闭后开区间】
     f.在语法正确的前提下，切片不会报错，结果要么是空列表，
      要么非空列表
"""
list1 = [11,22,33,44,55,66,77,88,99]

# 一、一般情况【有规律】
# 1.省略step（省略则默认step是1）
print(list1[1:4])  # [22, 33, 44]
print(list1[1:4:1])  # [22, 33, 44]

#【写出来end那么则前闭后开即末尾取不到】

# 2.省略start 【默认为第0个元素】
print(list1[:4])   # [11, 22, 33, 44]
print(list1[:4:1])  # [11, 22, 33, 44]

# 3.省略end
# 注意：若end未被省略，则不包含（即：取不到），如果省略，则包含
print(list1[1:])  # [22, 33, 44, 55, 66, 77, 88, 99]
print(list1[1::1])  # [22, 33, 44, 55, 66, 77, 88, 99]
print(list1[1:8])  # [22, 33, 44, 55, 66, 77, 88]

list1 = [11,22,33,44,55,66,77,88,99]

# 4.start和end都为正数
# a.end > start
print(list1[1:7])  # [22,33,44,55,66,77]
print(list1[1:7:1])  # [22,33,44,55,66,77]
print(list1[1:7:-1])  #[]


# b.start > end
print(list1[7:1])   # [] #因为：7+1 = 8不在索引内，所以为空列表
print(list1[7:1:-1])  # [88,77,66,55,44,33]#取不到22，因为：22是在索引为1的位置上，end只要写出来那么就是不包含尾部的
"""
判断切片之后的列表是否为空：
    a.计算start + step
    b.判断上述结果是否在start和end的范围内

注意：step的正负并不能决定是顺序获取还是倒序获取
    （因为还要看start,end）
"""
list1 = [11,22,33,44,55,66,77,88,99]
print(list1[7:1:-2])   # [88,66,44]
print(list1[1:7:2])    # [22,44,66]



list1 = [11,22,33,44,55,66,77,88,99]

# 5.start和end都为负数
# # a.end < start
print(list1[-1:-6])  # [] #因为 -1+1 = 0 ，0不在范围内
print(list1[-1:-6:-1])  # [99,88,77,66,55]

# b.end > start
print(list1[-6:-1])   # [44,55,66,77,88]
print(list1[-6:-1:-1])   # []

# 6.start和end其中一个为正数，一个为负数 
#0    1    2    3    4    5    6     7       8
#-9   -8  -7    -6  -5   -4    -3    -2      -1
print(list1[-1:6:1])  # []
print(list1[-1:6:-1])  # [99,88]

print(list1[-6:1:1])  # []
print(list1[-6:1:-1]) # [44,33]

print(list1[2:-2])   # [33,44,55,66,77]
print(list1[2:-2:-1])  # []
"""

如果start和end一个为正数，一个为负数，参照start， 
如果start为正数，则只需要观察正数索引，如果start为负数，
则只需要观察负数索引
如：1:-6:1,参照1，-6相当于是3，所以1:-6:1相当于1:3:1
"""


list1 = [11,22,33,44,55,66,77,88,99]
# 二、特殊情况【没有规律】
# 1.
print(list1[100:])   # []【所有的切片在语法正确的情况下是不会报错的】
print(list1[9:])   # 切片， []
#print(list1[9])  # 获取元素，IndexError

# 2.
print(list1[0:-1])  # [11, 22, 33, 44, 55, 66, 77, 88]
print(list1[0:8])  # [11, 22, 33, 44, 55, 66, 77, 88]

# 3.
print(list1[2:100])  # [33, 44, 55, 66, 77, 88, 99]
print(list1[2:])  # [33, 44, 55, 66, 77, 88, 99]

# 4.
print(list1[::])   # 顺序获取全部  [11, 22, 33, 44, 55, 66, 77, 88, 99]
print(list1[::-1])  # 倒序获取全部  [99, 88, 77, 66, 55, 44, 33, 22, 11]

# 5
list1 = [11,22,33,44,55,66,77,88,99]
print(list1[-1:0])   # []
print(list1[-1:0:-1])  # [99, 88, 77, 66, 55, 44, 33, 22]

# 6.
"""
负数::step
    如果step为正数，则表示顺序获取
    如果step为负数，则表示倒序获取
"""
print(list1[-6::1])  # -6:结尾:1
print(list1[-6::-1])  # -6:开头:-1


# 练习：
#    0    1   2   3   4   5   6
#   -7   -6  -5  -4  -3  -2  -1
a = ['a','b','c','d','e','f','g']

print(a[1:4:-1])   # []
print(a[4:1:-1])  # [edc]

print(a[-1:-4:-1])  # [gfe]
print(a[-4:1:-1])   # [dc]

print(a[4:20])   # ['e','f','g']
print(a[::-1])   # 倒序
print(a[-4::-1])  # [dcba]

"""
                 函数                	                   说明                   
              len(list)            	                获取列表元素个数                
              max(list)            	               返回列表元素最大值                
              min(list)            	               返回列表元素最小值                
              list(seq)            	                将元组转换为列表                
          list.append(obj)         	              在列表末尾添加新的对象               
           list.count(obj)         	            统计某个元素在列表中出现的次数             
          list.extend(seq)         	   在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）    
           list.index(seq)         	          从列表中找出某个值第一个匹配项的索引位置          
       list.insert(index,obj)      	                将对象插入列表                 
           list.pop(index)         	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值            【自己的疑问：若是想要移除任意一个元素那该怎么办呢？（列表的数据在对空间中，堆是先进后出码？*）】
          list.remove(obj)         	            移除列表中某个值的第一个匹配项             
           list.reverse()          	                反向列表中元素                 
  list.sort(key=None,reverse=False)	                对原列表进行排序                
             list.copy()           	                  复制列表                  
            list.clear()           	                  清空列表                  


[important skill]
	增：append()

	删：remove()   pop()

	改：reverse()    sort()

	查：len()    count()    index()   list()

"""
# 一、增加元素
# 语法：列表名.append(元素)

# 1.append():追加，在指定列表的末尾追加一个元素，注意：可以追加任何类型的数据,但是，一次只能添加一个数据
list1 = [11,22,33]
print(list1)
# a.添加单个元素
# 数字
list1.append(44)
print(list1)
# 字符串
list1.append("abc")
print(list1)

# b.添加多个元素，只能以容器的方式添加
# list1.append("abc",9,10)  # TypeError: append() takes exactly one argument (3 given)
list1.append(["xyz",9,123])#[11,22,33,"abc",["xyz",9,123]]
#列表直接是一个数据只不过是
print(list1)

# 2.extend()：扩展,在列表的末尾追加元素,将新序列中的元素打碎加入到原列表
# 注意：只能向其中添加序列【可迭代对象】【放多个数据的是一个容器来判断是不是可迭代对象】【append()是将这个容器整体加入，extend(）是添加容器中的东西】
# 可迭代对象：是一个容器，其中可以存储多个数据，字符串，列表，元组，字典和集合，range()都是可迭代对象
list1 = [11,22,33]
print(list1)
# list1.extend(44)  #TypeError: 'int' object is not iterable可迭代对象   iterator:迭代器 
list1.extend(["xyz",9,123])##[11,22,33,44,'abc',"xyz",9,123]
list1.extend("abc")#[11,22,33,'a','b',c']
#[字符串本身也是一个容器，容器中放的是多个不同的字符，此处将字符拆开了]
print(list1)

print(list1.extend("abc"))#None
#这是因为系统封装时候没有给你设计返回值，这打印的是这个函数用完之后的返回值

"""
【problem】：列表操作中append和extend的区别和联系
相同点
    a.都可以向列表中添加元素，而且都是添加在末尾
    b.都只能传递一个数据
    c.二者都是在原列表的基础上添加元素的，所以二者的返回值都是None
不同点
    a.append可以向列表中添加任意数据类型的数据，但是，extend只能添加可迭代对象【序列】
    b.如果要添加多个元素，append会将序列的整体添加到列表中，而extend只会添加元素
"""

# 3.insert(index,obj)：插入，向列表中指定的位置插入指定的元素
# 可以插入任意类型的数据
#append()也是可以插入任意的数据类型
list1 = [11,22,33]
print(list1)

# index在索引的取值范围内
list1.insert(1,44)#[11,44,22,33]
print(list1)

# 特殊情况：index超出索引的范围
list1.insert(10,55)   # 插入到末尾
print(list1)
list1.insert(-78,66)  # 插入到开头
print(list1)

list1.insert(1,[6,7,8])
print(list1)


##############################
# 二、删除元素

# 语法:列表名.xxxx()

# 1.remove(obj):移除，直接移除指定的元素，但是，一次只能移除一个
list1 = [1,2,3,4,5,6,7]
print(list1)
list1.remove(3)#//直接删除的是元素3，不是索引哈
print(list1)

list1 = [1,2,3,3,3,3,4,5,6,7]
print(list1)
list1.remove(3)
print(list1)

# a.注意：如果指定元素在列表中不存在，则无法删除，如果涉及到元素的删除，建议尽量先判断元素是否存在
# list1.remove(100)  # ValueError: list.remove(x): x not in list
# print(list1)
num = 100
if num in list1:
    list1.remove(num)
else:
    print("元素不存在")

# b.删除下面列表中的重复元素3
list1 = [1,2,3,3,3,3,4,5,6,7]
print(list1)
# list1.remove(3)
# print(list1)
# list1.remove(3)
# print(list1)
# list1.remove(3)
# print(list1)
# list1.remove(3)
# print(list1)
n = 0
while n < 4:
    if n in list1: #要判断，以防万一嘛
        list1.remove(3)
    n += 1
print(list1)
#【bug】此代码的局限性很大，针对此处的特定列表中的重复元素

# 2.pop(index)：弹出，index可以省略，如果省略，则默认删除列表中的最后一个元素，如果未省略，则删除指定索引的元素
list2 = [11,22,33,44,55]
print(list2)
list2.pop()
print(list2)

list2.pop(1)#列表的下标注意不要越界
print(list2)

# 注意：pop的时候，索引不能越界
# list2.pop(10)  # IndexError: pop index out of range
# print(list2)

# 3.clear()：清空（上来直接清空）
list3 = [11,22,33,44,55]
print(list3)
list3.clear()
print(list3)  # []

# 4.del
list3 = [11,22,33,44,55]
print(list3)
# del list3   # 直接删除列表本身（直接删除了这个容器本身）
del list3[0]    #（删除列表中指定的元素） list3.pop(0)
print(list3)

#[problem]
list3 = [11,22,33,44,55]
print(list3.remove(11))#None 
#【估计是因为remove()在封装时候没有设计返回值】

ele = list3.pop(1)
#（仅一家之言）若之后会用到被弹出的元素，那么可以用变量接收出来之后再用，注意打印时候打印列表本身，不要打印这函数整体一般
#ele是 22
"""
#代码以及执行结果
list3 = [11,22,33,44,55]
result = list3.pop(1)
print(result)
print(list3)
'''
22
[11, 33, 44, 55]

'''
"""
print(ele)   # 注意：删除指定索引的元素之后，返回该元素
print(ele + 19)



####################################
# 三、修改列表

# 1.reverse():反转，将列表元素倒序,在原列表的内部直接进行倒序
list1 = [11,22,33,44]
print(list1)
list1.reverse()
print(list1)

list1 = [11,22,33,44]
print(list1)
list2 = list1[::-1]   # 切片，生成了一个新的列表
#【错误思想：start,end默认就是0 到 结束呀，但是0+-1 = -1，不在范围内，应该是空列表呀。  此处应为特殊情况特殊记忆】

print(list2)
print(list1)

# 2.sort(reverse,key=函数)，排序，默认为升序
list1 = [3,100,45,29,11,88]
print(list1)
# a.升序
list1.sort()
print(list1)

# b.降序
list1 = [3,100,45,29,11,88]
list1.sort(reverse=True)  # 先升序，然后倒序
print(list1)

# c.key:自定义排序的规则
list1 = ["hhh","xyzzzzzz","fajj","aaaaa","nnnn"]
# 默认的排序规则为ASCII码
# list1.sort()
# print(list1)

# 需求：按照字符串的额长度进行排序
# list1.sort(key=len)
# print(list1)

list1.sort(key=len,reverse=True)
print(list1)

# 需求：按照数字大小排序
list1 = ["34","199","17","8","233"]
list1.sort(key=int)
print(list1)

# key的工作原理：将列表中的每个元素依次作用于指定的函数，根据函数计算的结果进行排序[最终的结果仍然是列表中是字符串的形式，因为key = int 只是排序的规则而已]

# 高阶函数：sorted【后面继续说】

#######################################
# 四、查找
# 1.len():获取列表的长度【获取列表元素的个数】
list1 = [23,5,5,4,6]
print(len(list1))
print(list1.__len__())  # 工作原理[计算机底层的执行]

# 2.count()：获取某个元素在列表中出现的次数
c = list1.count(5)
print(c)

# 优化：//只是针对这个特定的列表，若是换个列表那么就不行了，所以这是小一点的优化
list1 = [1,2,3,3,3,3,4,5,6,7]
print(list1)
key = 3
c = list1.count(key)
n = 0
while n < c:
    if n in list1:
        list1.remove(key)
    n += 1
print(list1)

# 3.max()/min():获取列表中元素的最值
print(max(list1))
print(min(list1))

# 4.index()：获取一个元素在列表中第一次出现的下标
list1 = [1,2,3,3,3,3,4,5,6,7]
i = list1.index(3)
print(i)

# 无法获取不存在的元素（的下标）
# i = list1.index(10)  # ValueError: 10 is not in list
# print(i)

# 5.list(x),将x转换为列表,x必须是可迭代对象
print(list("abc"))
print(list((45,6,5)))
print(list(range(1,20)))

#  列表的拷贝


import copy


# 一、引用赋值和列表拷贝
#  =    copy()[指的是：列表中的拷贝]
# 1.=
# a.一维列表
list1 = [44,55,66]
list2 = list1
print(list1)
print(list2)
print(list1 is list2)

list1[1] = 100
print(list1)
print(list2)
print(list1 is list2)
"""
[44, 55, 66]
[44, 55, 66]
True
[44, 100, 66]
[44, 100, 66]
True
"""

print("*" * 30)

# b.二维列表
list1 = [[11,22],[44,55,66]]
list2 = list1
print(list1)
print(list2)
print(list1 is list2)

list1[1][1] = 100
print(list1)
print(list2)
print(list1 is list2)
"""
[[11, 22], [44, 55, 66]]
[[11, 22], [44, 55, 66]]
True
[[11, 22], [44, 100, 66]]
[[11, 22], [44, 100, 66]]
True
"""

"""

对于列表的引用赋值而言，不管是一维列表还是二维列表，
只要其中一个列表的元素发生改变，则另一个列表也会随着
改变
注意：引用赋值不适用于列表的备份
"""


# 2.列表.copy()
# a.一维列表
list1 = [44,55,66]
list2 = list1.copy()
print(list1)
print(list2)
print(list1 is list2)

list1[1] = 100
print(list1)
print(list2)
print(list1 is list2)
"""
[44, 55, 66]
[44, 55, 66]
False
[44, 100, 66]
[44, 55, 66]
False
"""


# b.二维列表
list1 = [[11,22],[44,55,66]]
list2 = list1.copy()
print(list1)
print(list2)
print(list1 is list2)

list1[1][1] = 100
print(list1)
print(list2)
print(list1 is list2)
"""
[[11, 22], [44, 55, 66]]
[[11, 22], [44, 55, 66]]
False
[[11, 22], [44, 100, 66]]
[[11, 22], [44, 100, 66]]
False
"""
"""

    对于列表.copy而言
    一维列表，一个列表的元素发生改变，另一个列表不会发生改变
    二维列表，一个列表的元素【最里层的】发生改变，另一个列表会随着发生改变
    
    列表.copy也可以称为浅拷贝
"""



# 二、浅拷贝和深拷贝【important skill】
# 导入模块：import copy
# 1.浅拷贝：copy.copy()
# a.一维列表
list1 = [44,55,66]
list2 = copy.copy(list1)
print(list1)
print(list2)
print(list1 is list2)

list1[1] = 100
print(list1)
print(list2)
print(list1 is list2)
"""
[44, 55, 66]
[44, 55, 66]
False
[44, 100, 66]
[44, 55, 66]
False
"""



# b.二维列表
list1 = [[11,22],[44,55,66]]
list2 = copy.copy(list1)
print(list1)
print(list2)
print(list1 is list2)

list1[1][1] = 100
print(list1)
print(list2)
print(list1 is list2)
"""
[[11, 22], [44, 55, 66]]
[[11, 22], [44, 55, 66]]
False
[[11, 22], [44, 100, 66]]
[[11, 22], [44, 100, 66]]
False
"""



# 2.深拷贝：copy.deepcopy()
# a.一维列表
list1 = [44,55,66]
list2 = copy.deepcopy(list1)
print(list1)
print(list2)
print(list1 is list2)

list1[1] = 100
print(list1)
print(list2)
print(list1 is list2)
"""
[44, 55, 66]
[44, 55, 66]
False
[44, 100, 66]
[44, 55, 66]
False
"""

print("*" * 30)

# b.二维列表
list1 = [[11,22],[44,55,66]]
list2 = copy.deepcopy(list1)
print(list1)
print(list2)
print(list1 is list2)

list1[1][1] = 100
print(list1)
print(list2)
print(list1 is list2)
"""
[[11, 22], [44, 55, 66]]
[[11, 22], [44, 55, 66]]
False
[[11, 22], [44, 100, 66]]
[[11, 22], [44, 55, 66]]
False
"""

"""

    a.引用赋值：不管是几维列表，一个列表的元素改变，另一个随着改变
    b.列表.copy()和copy.copy()；
        对于一维列表，一个列表的元素改变，另一个不会改变
        对于二维列表，一个列表的元素改变，另一个会随着改变
    c.copy.deepcopy():不管是几维列表，一个列表的元素改变，另一个都不会改变
    
使用场景：一般用于备份
    一维列表，直接使用列表.copy()
    二维列表，建议使用copy.deepcopy()
"""

# 【problem  one】
a = [1,2,3]
b = [4,5]
c = [a,b]
d = c
e = c.copy()
a.append(20)
print(c,d,e)
"""
c：[[1,2,3,20],[4,5]]
d:[[1,2,3,20],[4,5]]
e:[[1,2,3,20],[4,5]]
"""

# 【problem  two】
a  = [1,2,['a','b']]
b = a
c = copy.deepcopy(a)
a[-1].append(3)
print(b)
print(c)
"""
b：[1,2,['a','b',3]]
c:[1,2,['a','b']]
"""

# 【problem  three】
a  = [1,2,['a','b']]
b = a
c = copy.deepcopy(a)
a.append(3)
print(b)
print(c)
"""
b:[1,2,['a','b'],3]
c:[1,2,['a','b']]
"""

2.5列表的嵌套

• 列表的嵌套，其实就是一个列表中的元素又是一个列表
• 操作嵌套列表，只要把要操作元素的下标当作变量名来使用即可

# 一维列表
list1 = [45,6,5,6,5]

# 二维列表
list2 = [[34,4],[3,5,4,545],[4]]
print(list2[1])
sublist = list2[1]
print(sublist[2])
print(list2[1][2])

3.标兵操练=

import copy

# =引用赋值
nums = [17, 39, 28, 51]
nums2 = nums
nums2.pop()
print(len(nums)) # 结果是什么，请描述原因
# 结果为3 ，原因：引用赋值，nums和nums2共用同一个地址，其中一个修改，另一个肯定修改

# 浅拷贝
numlist = [17, 22, 39, 58, [55, 43]]
nums3 = copy.copy(numlist)
print(numlist is nums3) # 结果是什么，请描述原因
# 结果为False，copy.copy()表示浅拷贝，外层会被拷贝生成一个新的地址，但是内部列表的地址保持不变，所以numlist和nums3指向两个地址
numlist[-1][0] = 99
print(nums3) # 结果是什么    [17, 22, 39, 58, [99, 43]]


# 深拷贝
values = [17, 32, [19, 42]]
nums4 = copy.deepcopy(values)
print(values[-1] is nums4[-1]) # 结果是什么，请描述原因
# 结果是False，copy.deepcopy()表示深拷贝，内外列表的地址都是新生成的，相互之间没有关系，所以地址是不一样的
"""
#已知一个列表 scores = [90, 89, 67, 98, 75, 87, 54, 88]，
#从控制台输入两个成绩，一个添加到scores的最后，另一个
#插入到scores的最前面"""
scores = [90, 89, 67, 98, 75, 87, 54, 88]
sco1 = int(input("请输入第一个成绩："))
sco2 = int(input("请输入第二个成绩："))
    
scores.insert(0,sco1)
scores.insert(len(scores),sco2)
print(scores)


"""已知一个数字列表nums = [1, 2, 5, 9]，根据该列表生成一个
新的列表，其中的元素是nums中每个元素的2倍，
例如：nums = [1, 2, 5, 9]   --->  nums = [2, 4, 10, 18]
"""
nums = [1, 2, 5, 9]
new_nums = []
for num in nums:
  new_nums.append(num * 2)

"""
将属于列表list1 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"]，但不属于列表list2 = ["Sun","Mon","Thu","Fri","Sat"]的所有元素定义为一个新列表list3
"""
list1 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"]
list2 = ["Sun","Mon","Thu","Fri","Sat"]
list3 = []
# 遍历list1
for week in list1:
  # 判断list1中的元素是否在list2中
  if week not in list2:
    list3.append(week)

"""
已知一个数字列表nums = [1, 2, 3,1, 4, 2, 1 ,3, 7, 3, 3]，
获取列表中出现次数最多的元素
"""
#使用字典实现
nums = [1, 2, 3,1, 4, 2, 1 ,3, 7, 3, 3]
num_dict = {}
for num in nums:
    if num not in num_dict:
        num_dict[num] = 1
    else:
        num_dict[num] += 1
max_count = max(num_dict)
for key,value in num_dict.items():
    if value == max_count:
        print(key)

"""
已知一个列表中保存的是学生的姓名，要求去掉重复的名字，
例如：names = ['张三', '李四', '大黄', '张三'] 
--- -->  names = ['张三', '李四', '大黄'] 
"""
#法一：
names = ['张三', '李四', '大黄', '张三']
for key in names:
    while names.count(key)>1:
        names.remove(key)
print(names)

#法二
names = ['张三', '李四', '大黄', '张三']
# 定义一个新的列表，用于重新保存元素
new_names = []
# 遍历原列表，判断元素在新列表中不存在，则添加到新列表中
for name in names:
    if name not in new_names:
        new_names.append(name)
print(new_names)

4.for循环

"""
基本使用

语法：

	for 变量名 in 序列【注意：只能是可迭代的对象】：

		循环体

功能：for循环主要用于遍历任何序列，比如列表，字符串，元组，字典和集合等

遍历：指的是依次访问列表中的每一个元素，获取每个元素值

说明：按照顺序获取列表中的每个元素，赋值给变量名，再执行语句，如此循环往复，直到取完列表中所有的元素为止

【whie循环的次数有你来控制，for有可迭代的对象的长度控制】

"""

# 1.for主要用于遍历序列【可迭代对象】
# 注意：如果序列存在，则可以直接遍历，循环的次数是由序列的长度控制的
list1 = [34,4,6,5]
for num in list1:
    print(num)

for ch in "ahfjahf":
    print(ch)

# 2.如果for循环仅仅为了控制循环的次数，则变量名可以使用_替代
for _ in "aaaaa":#此处的字符串只是控制次数，没有实际的意义
    print("hello world")


#############################列表遍历##########
# 遍历列表的工作原理：在计算机的底层，还是通过遍历可迭代对象的下标实现的``
list1 = ['a','b','c']

# 1.while
n = 0
while n < len(list1):
    print(list1[n])
    n += 1

# 2.for：直接操作元素
for m in list1:
    print(m)

# 3.for；操作索引
for k in range(len(list1)):
    print(k,list1[k])

# 4.enumerate枚举
# 思路：将列表转换为枚举
result = enumerate(list1)
print(result)
for index,ele in result:#index是enmertate的下标
    print(index,ele,list1[index])

for index,ele in enumerate(list1):
    print(index,ele)

# a,b = (45,100)
# print(a,b)

"""
while和for的使用场景：
    while循环：不确定循环次数
    for循环：确定循环次数
"""

'''
>>> list1=['a','b','c'];
>>> result = enumerate(list1);
>>> print(result)
<enumerate object at 0x02D16940>
>>> for index,ele in result:
...   print(index,ele,list1[index])
...
0 a a
1 b b
2 c c
>>> for index,ele in enumerate(list1):
...  print(index,ele)
...
0 a
1 b
2 c
>>> a,b = (45,100);
>>> print(a,b)
45 100

'''
####【practice]
# 1.获取指定列表中下标为偶数的元素
list1 = [34,6,5,65,75,7]

n1 = 0
while n1 < len(list1):
    if n1 % 2 == 0:
        print(list1[n1])
    n1 += 1

for n2 in range(len(list1)):
    if n2 % 2 == 0:
        print(list1[n2])

# 2.求1~100之间的所有整数的和
total = 0
for num in range(1,101):
    total += num

# 3.打印九九乘法表
for i in range(1,10):
    for j in range(1,i + 1):
        print("%dx%d=%d" % (j,i,i * j),end=" ")
    print()

# 4.遍历二维列表
list2 = [[34,4],[3,5,4,545],[4]]

for sublist in list2:
    for num in sublist:
        print(num)

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