元组（其他语言：数组）

1.特征：
    有序：有索引值 -- 正序、反序
    不可以增删改，可以查（元组在内存中一旦开辟了内存空间后，这个内存空间是不可以改变的）
2.标识符：（） 和 逗号
3.关键字：tuple

使用场景：
    1，格式化输出
    2，保证数据的安全
    3，函数参数、返回值 -- 元组

空元组
    tp =()   # 另外一种写法 tuple()
    print(len(tp), type(tp))
    只包含一个元素的元组
    tpl = ('hello python ' ,)   # 以逗号确认元组里面数据个数
    print(type(tpl))     # 只有一个元素是，如果不加逗号，则不会元组类型<class 'str '>

非空元组
    tpl = (1,' hello '，3.123，True，[1，2，3]，( 'a', 'b ','c '))print(len(tpl),type(tpl))
    res = tpl + tpl  #  元组是不能修改和新增的，所以加法运算是生成一个新的元组
    print(res)
    res2 = tpl * 2
    print(res2)

元组只能做查的操作，不能做增删改的操作

语法:
    单个元素:元组名[索引值]       // 元组的角标从0开始数，末尾从-1开始数
    多个元素值:元组名[start:end :step]  // star:起始点角标，end:结束点角标，step:步长意思是隔step距离取一个值
    元组里面的元素可以是任意的数据类型

单个元素:
tpl =(1,' hello'，3.123，True，[1，2，3],('a', 'b','c '))
    // 输出"hello'
    res0 = tpl[1]
    print(res0)

    // 输出 ('a', 'b','c ')
    res1 = tpl[-1]   #  获取元组tpl里面最后一个元素，- 负数符号表示从元组的后面向前反向取数据
    print(res1)

    // 输出2,3
    res2 = tpl[-2]   # [1,2,3] // 列表 list
    res3 = res2[1:]  # 1: 意思是把列表中的1作为工具对列表进行切片操作，从而得到剩下的部分即:(2,3)
    #  另一种直接的写法：res3 = tpl[-2][1:]
    print(res3)

    // 输出'o'
    // res4=tpl[1]   # hello
    // res5=res4[-1]
    res5 = tpl[1][-1]
    print(res5)

多个元素值:
tp2 = (1，2，3，4，5，6，7)
print(tp2[0:2]) # 元组取值有个 [)  左闭右开的原则，
# (1,2)
print(tp2[1:3])
# (2,3)

print(tp2[1:3:1])   # 元组名[start:end :step]  // star:起始点角标，end:结束点角标，step:步长意思是隔step距离取一个值
# (2,3)
print(tp2[1:5:2])
# (2,4)
print(tp2[1:7:2])
# (2,4,6)
print(tp2[0:3:2])
# (1,3)

查看元素的索引值:   l.index('元素")
统计元素的个数:    l.count('元素")

tpl = (1,'hello',3.123,True,[1，2，3],('a','b ','c'))
print(list(tpl))    # 元组-->列表
print(tpl.index(3.123))
#   2
#判断:3是否在tpl的倒数第二个元素中?
res = tpl[-2]
print(3 in res)     // 这里用 in 做判断
#   True
print(tpl.count(1)) // 这是元组在内存中的存储方式决定的，有个内存地址引用问题
#   2  (因为True也是1)

元组转换函数:tuple()
    字符串--元组
    列表--元组
    数值类型不可以转为元组

列表

标识符:[]
关键字:list
列表中的元素支持字符、数字、字符串设置可以包括列表〈即嵌套），元索与元素之间都逗号隔开，元素值可以被修改有序数据，即有索引值
列表可以增删改查操作

    #空列表
        lst =[]
    #非空列表
        lst2 =[1，2，3，4]
        print(type(lst))# <class 'list '>
        print(type(lst2))#<class 'list'>
        print(len(lst2))
    #列表中的元素内容
        lst3 =[100，3.14，True,"huace ",[1,2,3，4]]
        # print(lst2[::-1])
        print(lst2)
        lst2.reverse()  # 反转
        print(lst2)
        
        print("切片取值：",lst3[1:5:2])
        # 切片取值：[3.14,'huace']

列表:有序可变
        有序:每个元素都有索引值
            正序
            反序
    列表的取值:变量名[索引值]
    列表的切片:变量名[start:end:step]取头不取尾
    可变:列表中的元素值是可以修改、删除、增加的
    # 所有的复合型数据类型,在python都是存储最后的实际数据
    查询 直接用[]
    新增 用.号 调用这个列表的方法

增加元素
# append()  # 一次只能加一个元素，会追加在原列表的最后面
  insert(0,'tom')   # 向列表指定位置插入数据（列表是内存中一个连续不能断的数据,本质还是追加数据）
    lst3 = [1,2,3]
    print(lst3)
    lst3.append('huace')
    lst3.append('python')
    lst3.insert(0,'tom')    # 把'tom'插入到列表0角标处，原0角标位置的数据和后面的所有数据向后平移一个位置
    # ['tom',1,2,3]

  extend() 一次只能加多个元素,内容必须是列表类型
    ls = 【10,20,30]
    res = lst3 + ls # 不建议直接相加【可读性比较差】
    print(res)
    print(lst3)
    lst3.extend(ls)
    lst3.extend(' huace ')  # [1，2，3，'h ', 'U', 'a ', 'c ', 'e ']
    # lst3.extend(100)  # 报错，数字类型是整体，不可以分割 TypeError:
    lst3.extend([100])  # ok, [100] 这是列表类型
    print(lst3)

删除元素
    删除元素底层逻辑都是回收内存空间，删除元素其它元素前移，最后一个位置内存空出来回收掉
    #remove(元素值)    是依次删除数据，并且从前到后进行删除，删除指令只执行一次
        lst3 = [100，3.14，True,"huace ", [1，2，3，4]]
        # print(lst3)
        lst3.remove("huace ")   # 如果元素值不存在，则会报错,ValueError
        print(lst3)

    #pop(索引值)
        print(lst3)
        lst3.pop()  # 不带索引，默认删除最后一个元素
        print(lst3)

    #clear()    # 清空
        print(lst3)
        lst3.clear()
        print(lst3)

    #del删除 
        del 变量名[索引值]    
        del 变量名[start: end :step]
    # del 是python里面的一个关键字，是一个直接销毁内存的一种方式
    # del 可以删除python解释器中的任何内容,执行销毁动作
        # print(lst3)
        # del lst3[-2]
        # print(lst3)

修改元素
    变量名[索引值] = 新的值  // 拿到id 重新赋值
    变量名[start:end:step] = 新的值

        lst3 = [100，3.14，True,"huace " ,[1，2，3，4]
        print(lst3)
        lst3[-2] = 'python '
        print(lst3)
        # [100，3.14，True,' huace ',[1，2，3，4]]
        # [100，3.14，True,' python'，[1，2，3，4]]

    切片的方式
      切片修改列表数据的方式,必须赋值的是一个列表，和extend一样
        lst3 = [100，3.14,True,'python',[1，2，3，4]]
        print(lst3)
        lst3[:3][100]   // 角标0到角标3对应的数据 用100进行替换(前闭后开所以不包括角标3对应的数据)
        print(lst3)
        lst3[:3] = 'True '  // 这里是给lst3列表重新赋值 ['T', 'r', 'u', 'e']
        print(lst3)
        # ['T', 'r', 'u', 'e']
        lst3[:3] = [True]   // lst3列表中 'T', 'r', 'u' 用 True替换
        print(lst3)
        # [100，3.14,True,'python',[1，2，3，4]]
        # [100,' python'，[1，2，3，4]]
        # [True,'e']

其他方法
    index() 统计元素的索引值,获取索引位置
    count() 统计元素的个数
    
    lst3 = [1,3.14,True," huace " ,[1,2,3.4]]
    print(lst3.count(100))
    # 0
    print(lst3.count(True))     # true是1，false是0
    # 2
    # print(lst3.index(100))
    # print(lst3)
    # lst3.pop(0)
    # print(lst3)

转换函数
    list()  将其他数据类型转为列表数据类型
    总结:
        数值类型不可以转换为列表类型,因为数值类型是一个不可拆分的整体
        字串可以转换为列表类型，可迭代的数据类型
            s = 10
            # print(list(s))    #TypeError: 'int' object is not iterable
            s2 = 3.14
            # print(list(s23)   #TypeErrop: 'flaat' object is not iterable
            s3 = True
            # print(list(s3))   #TypeErrop: 'bool' object is not iterable
            s4= 'hello '
            print(list(s4)) 
            # ['h','e','l','l','o']

我们现在获取list中的元素的方法有哪些?
    1、切片:[1:23] 给定一个左闭右开的一个区间范围，区间范围能确定的根本原因是因为它在内存中连续不中断
    2、索引:根本原因也是因为它在内存中连续不中断

循环结构_for

for循环

使用场景:
    1:遍历
    2:循环
语法:
    for 变量名 in 可迭代的数据;
        循环体
        
可迭代的数据:字符串、列表、元组、字典、集合、range序列

循环:
    1:循环次数根据可迭代的数据的长度来决定
    2:变量名获取的迭代数据中的每一个元素

whie循环 --> 基于判断条件 [True/False]
for循环 --> 基于对数据的遍历[]


for i in ["a","b"，"c"，"d"]: # 相当于依次将"a"，"b"，"c"，"d”赋值给i，
    print(i)
    # a
    # b
    # c
    # d


range(1,10) // 可迭代数据，是一个左闭右开的范围区间数据，以整数来确定的
range(100)  // 确定右区间值，左区间值默认为0开始
    # range是一个范围区间
    # 在python2中range是一个可迭代列表
    # 在python3中range已经变成了迭代器


    for i in range(1,10):
        for j in range(1,i +1):
            print( "{}*{}={}".format(i，j，i*j),end=' ')
        print() // 作用是换行

    #   range(1,10)
    #   1*1=1
    #   2*1=2   2*2=4
    #   3*1=3   3*2=6   3*3=9
    #   4*1=4   4*2=8   4*3=12  4*4=16
    #   5*1=5   5*2=10  5*3=15  5*4=20  5*5=25
    #   6*1=6   6*2=12  6*3=18  6*4=24  6*5=3   6*6=36  
    #   7*1=7   7*2=14  7*3=21  7*4=28  7*5=35  7*6=42  7*7=49
    #   8*1=8   8+2=16  8*3=24  8*4=32  8*5=40  8*6=48  8+7=56  8+8=64
    #   9*1=9   9*2=18  9w3=27  9*4=36  9*5=45  9*6=54  9*7=63  9+8=72  9*9=81