2021-06-18

温度转换实例
import string
def node1():【】
    t1=input("输入带单位的温度值:")
    if t1[-1] in ['F','f']:
        C=(eval(t1[0:-1])-32)/1.8
        print("转换后的温度是{:.2f}C".format(C))
    elif t1[-1] in ['C','c']:
        F=1.8*eval(t1[0:-1])+32
        print("转换后的温度是{:.2f}F".format(F))
    else:
        print("输入格式错误")
    def node2():
 #字符串
     t2="110c"
     print(t2[-1])
     print(t2[0:-1])
 #eval()函数的用法：去掉字符串的双引号
 #转义符字符
 #用反斜杠开头的字符串，来表示一些特定意义的字符。这些叫做转义字符
 #\n：表示换行符   | \t: 表示制表符    |\\： 表示斜线  |\" :表示双引号


	def node3():
#整数型
	print(pow(2,10))
#浮点型 0.0与0在计算机中有差别
    print(sys.float_info)
    print(sys.float_info.max)
#数字类型：
# +：和|   -：差   |*：乘   |/：商  | //：x与y的整数商，即不大于x与y的最大整数
# %：x与y商的余数  |x**y  : x的y次幂| +x: x的本身
    print(100/3)
    print(30-3**2+8//3**2*10)
    print(3*4**2/8%5)
    print(2**2**3)
    print((2.5+1.25j)*4j/2)


def node4():
#字符串类型的表示
	name="python语言成序设计"
    print(name[0])
    print(name[0],name[7],name[-1])
    print(name[:6])
    print(name[2:-4])
    print(name[6:])
    print(name[:])
#基本字符串操作符
#x+y : 连接两个字符串x与y
	name2="python"+"语言"+"程序"+"设计"
	print(name2)
#x*n或n*x  : 复制n次字符串x
	print("G"*3)
#x in s :如果x是s的子串,返回true,否则返回False
	print("python"in name2)
#str[i]：索引，返回第i个字符
	jiu="jason"
	print(jiu[0])
#str[N:M]:切片，返回索引第N到第M的子串，其中不包含M
	print(jiu[1:3])
#len(x):返回字符串x的长度，也可返回其他组合数据类型元素个数
#替换
	print(jiu.replace("j","i"))
#str(x):翻书任意型x所对应的字符串形式
#chr(x):返回Unicode编码x对应的单字符
#ord(x):返回单字符表示的Unicode编码
#hex(x):返回整数x对应十六进制数的小写字符串
#oct(x):返回整数x对应的八进制数的小写形式字符串
    print(hex(225))
    print(oct(-225))

def node5():
#字符串类型的格式化
#format()的基本使用
#format()的基本格式： <模板字符串>.format(<逗号分割的参数>)
#模块字符串由一系列槽组成，用来控制修改字符串嵌入值出现的位置，主要原理是将逗号分隔的参数按照序号关系替换到模板字符串的槽中，
#槽用{}表示，如果大括号没有序号，则按照出现顺序替换
    print("{}:计算机{}的CPU占用率为{}%".format("2016-12-31","python",10))
    print("{1}:计算机{0}的CPU占用率为{2}%".format("2016-12-31","python",10))
#format()可以链接不同类型的变量和内容
    print("{}{}{}".format("圆周率是",3.1415926,"..."))
    print("圆周率{{{1}{2}}}是{0}".format("无理数",3.1415926,"..."))   #如果需要输出大括号，则用{{{  表示{  ,}}}表示}
    s=""
    print("圆周率{{{1}{2}}}是{0}")  #大括号本身是字符串的一部分
    print(s.format("无理数",3.1415962,"..."))   #当调用format()时解析大括号
#format()的格式控制
#模板字符串内槽的格式如下：
#{<参数序号:<格式控制标记>>}
#格式控制标记用来控制参数显示时的格式
#: 引导符号   |  <填充> ：用于填充单个字符  | <对齐>： <左对齐  >右对齐 ^居中对齐  | <宽度>：槽的设定输出宽度
#<,>:数字的千位分隔符，适用于整数和浮点数   | <.精度>:浮点数小数部分的精度或字符串的最大输出长度
#<类型>：整数类型：b,c,d,o,x,X    浮点数类型：e.E,f,%
    q="PYTHON"
    print("{0:30}".format(q))   #默认左对齐
    print("{0:>30}".format(q))  #右对齐
    print("{0:*^30}".format(q))  #居中切使用*填充
    print("{0:-^30}".format(q))  #居中1且使用-填充
    print("{0:3}".format(q))     #设定宽度3比format()参数长度小，使用参数实际长度
    print("{0:-^20,}".format(1234567890))  #(,)显示千位分隔符
    print("{0:-^20}".format(1234567890))   #对比输出
    print("{0:-^20,}".format(12345.67890))
    print("{0:.2f}".format(12345.67890))    #<.精度>：由小数点(.)开头。对于浮点数，精度表示小数部分输出的有效位数
    print("{0:H^20.3f}".format(12345.67890))
    print("{0:.4}".format("PYTHON"))        #对于字符串，精度表示输出的最大长度
#<类型>： 对整数型： b:输出二进制      c:输出整数对应的Unicode字符    d：输出十进制   o:输出八进制
#x：输出小写十六进制      X：输出大写十六进制
print("{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425))
#浮点数类型： e：输出浮点数对应的小写字母e的指数形式   E：输出大写字母E的指数形式
#f：输出浮点数的标准浮点形式    %：输出浮点数的百分式形式
    print("{0:e},{0:E},{0:f},{0:%}".format(3.14))
    print("{0:.2e},{0:.2E},{0:.2f},{0:.2%}".format(3.14))


def node6():
    #成语的分支结构
    #单分支结构：if语句
    #python关系操作符： <：小于 |   <=:小于等于  |   >=:大于等于|   >: 大于   |  ==：等于  |!=： 不等于
	    if 4<5:
	        print("true")
    #二分支结构：if----else语句
    #格式：if<条件>:
    #      <语句块1>
    # else:
    #      <语句块2>
    #语句块1是在if条件满足后执行的一个或多个语句序列，语句块2是if条件不满足后执行的语句序列。
    #二分支语句用于区分条件的两种可能，即True或False,分别形式执行路径
    #简洁模式： <表达式1> if <条件> else <表达式2>
    #轻重表达式1,2一般是数字类型或字符串类型的一个值。例：
	    PM=eval(input("请输入PM2.5数值:"))
	    print("空气{}污染!".format("存在" if PM>=75 else "没有"))
    #多分支结构：if-elif-else语句
    #语句格式为；
    #if <条件1>：
    #   <语句块1>
    #elif <条件2>:
    #     <语句块2>
    # ....
    # else:
    #    <语句块n>
    #python依次评估寻找第一个结构为True的条件，执行该条件下的语句块，借宿欧跳过整个if-elif-else语句，执行后面的语句
    #如果没有任何条件成立，else下面的语句块将被执行。else子句是可选。例：
	    if 0<=PM <35:
	        print("空气优质")
	    elif 35 <= PM <75:
	        print("空气良好")
	    else :
	        print("空气污染")


def node7():
    #陈旭的循环结构：
    #遍历循环：for语句
    #语句格式：
    #for <循环变量> in <遍历结构>:
    #  <语句块>
    #常用的使用方法：
    #循环N次：
	    for i in range(5):
	        print(i)
    #遍历文件fi每一行：
	    '''for line in fi:
	        <语句块>'''
    #遍历字符串s：
	    for x in "PYTHON":
	         print(x)
    #遍历列表ls:
	    ls=[452]
	    for item in ls:
	        print(item)
    #扩展模式：
    #for <循环变量> in <遍历结构>:
    #     <语句块1>
    #else:
    #    <语句块2>
    #在此模式汇总，当for循环正常执行之后，程序会继续执行else语句中的内容。else语句旨在循环正常执行并结束后才执行
    #因此可以在<语句块2>中放置判断循环执行情况的语句。例：
	    for s in "BTI":
	        print("循环进行汇总:"+s)
	    else:
	        s="循环正常结束"
	        print(s)
    #无限循环：while语句
     #语法格式为：
    #while <条件>:
    #   <语句块>
    #其中条件与if语句中的判断条件一样，结果为True与False
    #使用过程：当条件判断为True时，循环体重复执行语句块中的语句；当条件为False时。循环终止，执行与while同级别缩进的后续语句
    #使用保留字else的扩展模式，格式为：
    #whlie <条件>:
    #    <语句块1>
    #else:
    #   <语句块2>
    #此模式中，当while循环正常执行后，程序会继续执行else语句中的内容。else语句旨在循环正常执行后才执行，
    #因此，可以在语句块2中放置判断循环执行情况的语句。 例：
	    a,idx="BIT",0
	    while idx < len(a):
	        print("循环进行中:"+a[idx])
	        idx+=1#idx=idx+1
	    else:
	        s="循环正常结束"
	    print(s)
    #循环保留字break,continue
    #break 用来跳出最内层for或whlie 循环，脱离该循环后，程序从循环代码后继续执行。
	    for  b in "BIT":
	        for i in range(10):
	            print(b,end="")
	            if b=="I":
	                break
    #其中，break语句跳出了最内层for循环，但仍继续执行外层循环。每个break语句只有能力跳出当前层次循环
    #continue 用来结束当前循环，即跳出循环体重下面尚未执行的语句，但不跳出当前循环.
    #对于while循环，继续求解循环条件
	    c="PYTHON"
	    d=0
	    while d< len(c):
	
	        if c[d]=="T":
	
	            break
	        else:
	            print("正常循环:"+c[d])
	            d+= 1
    #对于for循环，程序流程接着遍历循环列表
    for s in "PYTHON":
        if s == "T":
            continue
    print(s, end="")

def main():

    #node1()
    # node2()
    # node3()
     node4()
    # node5()
    # node6()
    # node7()



 if __name__ == '__main__':
      main()

‘’’

函数的调用与定义

    import random
from re import T


def log1():
    #random库的使用
    #random()库的9个常用随机数生成函数
    #seed(a=None) :初始化随机数种子，默认值为当前系统时间
    #random()     :生成一个[0.0,1.0)之间的随机小数
    #randint(a,b) :生成一个[a,b]之间的整数
    #getrandbits(k):生成一个k比特长度的随机整数
    #randrange(start,stop[,step]):生成一个[start,stop)之间以step为步数的随机整数
    #uniform(a,b) :生成一个[a,b]之间的随机小数
    #choice(seq)  :从序列类型，例如列表中随机返回一个元素
    #shuffle(seq) :将序列类型中的元素随机排列，返回打乱后的序列
    #sample(pop,k):从pop类型中随机选出k个元素，以列表类型返回
    print(random.random())
    print(random.uniform(1,10))
    print(random.randrange(0,100,4))
    print(random.choice(range(100)))
    ls=list(range(10))
    print(ls)
    random.shuffle(ls)
    print(ls)
    #生成随机数之前可以通过seed()函数制定随机数种子，随机数种子一般是一个整数，只要种子相同，每次生成的随机序列也相同。
    random.seed(125)
    print("{}.{}.{}".format(random.randint(1,10),random.randint(1,10),random.randint(1,10)))

def log2():
    #程序的异常处理
    #try-except 语句
    #语法格式为：
    # try:
    #     <语句块1>
    # except <异常类型>:
    #     <语句块2>
    try:
        num=eval(input("请输入一个整数:"))
        print(num**2)
    except NameError:
        print("输入错误，请输入一个整数!")
    #异常的高级用法
    #语法形式为：
    # try:
    #     <语句块1>
    # except <异常类型>:
    #     <语句块2>
    #     ....
    # except <异常类型N>:
    #     <语句块N+1>
    # except:
    #     <语句块N+2>
    try:
        alp="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        idx=eval(input("请输入一个整数："))
        print(alp[idx])
    except NameError:
        print("输入错误，请输入一个整数!")
    except:
        print("其他错误")
def log3():
    #异常语句还可以与else和finally保留字配合使用
    #语法格式如下：
    # try:
    #     <语句块1>
    # except <异常类型1>:
    #     <语句块2>
    # else:
    #     <语句块3>
    # finally:
    #     <语句块4>
    #此处的else与for循环和while循环中的else一员，当try中的语句块1整除执行结束且没有发生异常时，else中的语句块3执行，
    #可以看做是对try语句块正常执行后的一种追加处理。
    #finally则不用，无论try中的语句块1是否发生异常，语句块4都要执行，可以将程序执行语句块1的一些收尾工作放在这里
    #例
    try:
        alp="ABCDEFGHIJKLMNOPQRSTUVWSYZ"
        T-eval(input("请输入一个整数:"))
        print(alp[T])
    except NameError:
        print("输入错误，请输入一个整数!")
    else:
        print("没有发生异常")
    finally:
        print("程序执行完毕，不知道是否发生异常")

def han():
    #函数和代码复用
    #函数的定义：函数是一段具有特定功能的，可重用的语句组，用函数名来表示并通过函数名进行功能调佣
    #使用函数的目的：降低编程难度和代码复用
    #python中使用def保留字定义一个函数，语法形式如下：
    #def<函数名>(<参数列表>:)
    #<函数体>
    #return<返回值列表>
    #计算n!
    def fact(n):
        s=1
        for i in range(1,n+1):
            s*=i
        return s
    #函数的定义： Y=f(x)
    #函数定义时，所指定的参数是一种占位符
    #函数定义后，如果不经过调用，不会被执行
    #函数定于时，参数是输入，函数体是处理，结果是输出
    #函数的调用
    #调用时要给出实际参数
    #实际参数替换定义时定义中的参数
    #函数调用后得到的返回值
    # 函数的调用的过程：
    # (1)调用程序在调用出暂停执行
    # (2)在调用时将实参复制给函数的形参
    # (3)执行函数体语句
    # (4)函数调用结束给出返回值，程序回到调用前的暂停处继续执行。
    #例
    fact(10)
    #函数参数的传递
    #参数个数；函数可以有参数，也可以没有，但必须保留括号
    #def <函数名>():
    #    <函数体>
    #    return <返回值>
    #例
    def fact():
        print("我也是函数")
    #可选参数传递：函数定义时可以为某些参数指定默认值，构成可选参数
    # def <函数名>(<非可选参数>，<可选参数>):
    #     <函数体>
    #     return <返回值>
    #例  计算n!//m
    def hide(n,m=1):
        s=1
        for i in range(1,n+1):
            s*=i
        return  s//m

    hide(10)
    hide(10,5)
    #可变参数传递：函数定义时可以设计可变数量参数，既不确定参数总数量
    #格式如下：
    # def <函数名>(<参数>,*b):
    #       <函数体>
    #       return  <返回值>
    #例：就散n!乘数
    def hi(n,*b):
        s=1
        for i in range(1,n+1):
            s*=i
        for item in b:
            s*=item
        return  s

    hi(10,3)
    hi(10,3,5,8)
    #参数传递的两种方式：函数调用时，参数可以按照位置或名称方式传递
    #位置传递
    hide(10,5)
    #名称传递
    hide(m=5,n=10)
    #函数的返回值：函数可以返回0个或多个结果
    #return 保留字用来传递返回值
    #函数可以有返回值，也可以没有，可以有return，也可以没有
    #return 可以传递0个返回值，也可以传递任意多个返回值
    #函数调用时，参数可以按照位置或名称方式传递
    #例
    def fact(n,m=1):
        s=1
        for i in range(1,n+1):
            s*=i
        return s//m,n,m
    fact(10,5)
    #输出为元组类型：(725760,10,5)

def var():
    #局部变量与全局变量
    #全局变量：指在函数之外定义的变量，一般没有缩进，在程序执行过程全过程有效。
    #局部变量：指在函数内部使用的变量，仅在函数内部有效，当函数退出时变量将不存在
    n=1   #全局变量
    def func(a,b):
        c=a*b         #c是局部变量，a和b作为函数参数也是局部变量
        return c
    s=func("knock~",2)
    #print(c)   说明函数执行完后，其内部变量将被释放
    #规则1：局部变量和全局变量是不同变量
    #局部变量是函数内部的占位符，与全局变量可能重名但不同
    #函数运算后，局部变量被释放
    #可以用global保留字在函数内部使用全局变量
    #例
    n=1    #n是全局变量
    def func2(a,b):
        n=b    #这个n是在函数内存中新生成的局部变量，不是全局变量
        return  a*b
    s=func2("knock",2)
    print(s,n)  #测试一下n值是否改变
    #例：使用global保留字
    n,s=10,1000
    def func3(n):
        global s              #使用global保留字声明此处s是全局变量s
        for i in range(1,n+1):
            s*=i
        return s              #此处指全局变量s
    print(func3(n),s)         #此处全局变量s百日函数修改

    #规则2：局部变量为组合数据类型且未创建，等同于全局变量
    #例
    ls=["F","f"]       #通过使用[]真是创建一个全局变两列表ls
    def func4(a):
        ls.append(a)   #此处ls是列表类型，未真实创建，则等同于全局变量
        return
    func4("c")         #全局变量ls被修改
    print(ls)
    #输出结果：['F','f','c']

    def func5(a):
        ls=[]       #此处ls是列表类型，真实创建，ls是局部变量
        ls.append(a)
        return
    func5("c")      #局部变量ls被修改
    print(ls)
    #输出结果：['F','f']
    #总结：
    #基本数据类型，无论是否重名，局部变量与全局变量不同
    #可以通过global保留字在函数内部声明全局变量
    #组合数据类型，如果局部变量未真实创建，则是全局变量

def shu():
    #lambda函数
    #lambda函数是一种匿名函数，即没有名字的函数
    #使用lambda保留字定义，函数名是返回结果
    #lambda函数用于定义简单的，能够在一行内表示的函数
    #格式：
    #<函数名>=lambda <参数>:<表达式>
    #例
    f=lambda x,y:x+y
    f(10,15)
    #结果  25
    f=lambda :"lambda函数"
    print(f())
    #结果：lambda函数

def main():
    #log1()
    # log2()
    # log3()
    han()
    var()
    shu()




if __name__ == '__main__':
    main()

代码复用与函数递归

    #代码复用：把代码当初自愿进行抽象
    #代码资源化：程序代码是一种用来表达计算的资源
    #代码抽象化：使用函数等方法对代码赋予更高级别的定义
    #代码复用：同一份代码在需要时可以被重复使用
    #函数和对象是代码复用的两种主要形式
    #函数：将代码名在，在代码层面建立了初步抽象
    #对象：属性和方法，<a>.<b>和<a>.<b>() 在函数智商再次组织进行抽象
    #模块设计：分而治之
    #通过函数或对象封装程序划分为模块及模块间的表达
    #具体包过：主程序，子程序和子程序间的关系
    #分而治之：一种分而治之，分层抽象，体系化的设计思想
    #模块设计：紧耦合，松耦合
    #紧耦合：两个部分之间交流很多，无法独立存在
    #松耦合：两个部分之间交流较少，可以独立存在
    #模块内部紧耦合，模块之间松耦合

函数递归的理解

    #递归的定义：函数定义中调用函数自身的方式
    #两个特征：
    #链条：计算过程层递归链条
    #基例：存在一个或多个不需要再次递归的基例
    #递归的实现：例：n!
    def fact(n):
        if n==0:
            return 1
        else:
            return n*fact(n-1)
    #递归的实现：函数+分支语句
    #递归本身是一个函数，需要函数定义方式描述
    #函数内部，采用分支语句对输入参数进行判断
    #基例和链条，分别编写对应代码
    #函数递归实例解析
    #字符串反转：将字符串s反转输出
    #例
    def rvs(s):            #函数+分支结构
        if s=="":
            return s       #递归链条
        else:
            return rvs(s[1:])+s[0] #递归基例
    #输出结果为：s[::-1]
    #斐波那契数列：F(n)=F(n-1)+F(n-2)
    def f(n):
        if n==1 or n==2:
            return 1
        else:
            return f(n-1)+f(n-2)

组合数据类型

集合类型

``
    def gather():
    #集合类型的定义：集合是多个元素的无序组合
    #集合元素之间无序，每个元素唯一，不存在相同元素
    #集合元素不可更改，不能是可变数据类型
    #集合用大括号{}表示，元素间用逗号分隔
    #建立集合类型用{}或set()
    #建立空集合类型，必须使用set()
    #例
    A={"python",123,("python",123)}  #使用{}建立集合
    #输出结果：{123,'python',('python',123)}
    B=set("pypy123")                 #使用set()建立集合
    #输出结果：{'1','p','2','3','y'}
    C={"python",123,"python",123}
    #输出结果：{'python',123}
    #集合操作符
    #并：S|T   ; 差：S-T   ; 交： S&T   ; 补：S^T
    #S|T:并，返回一个新集合，包括在集合S和集合T中的所有元素
    #S-T:差，返回一个新集合，包括在集合S但不在T中的元素
    #S&T:交，返回一个新集合，包括同时在集合S和T中的元素
    #S^T:补, 返回一个新集合，包括集合S和集合T中的非同元素
    #S<=T或S<T:返回true/false,判断S和T的子集关系
    #S>=T或S>T:返回true/false,判断S和T的包含关系
    #S|=T:并，更新集合S，包括在集合S和T中的所有元素
    #S-=T:差，更新集合S，包括在集合S但不在T中的元素
    #S&=T:交，更新集合S，包括同时在结合S和T中的元素
    #S^=T:补，更新集合S，包括集合S和T中的非同元素
    #例
    D={"p","y",123}
    E=set("pypy123")
    print(D-E)  #结果为：{123}
    print(D&E)  #结果为：{'p','y'}
    print(D^E)  #结果为：{'2',123,'3','1'}
    print(E-D)  #结果为：{'3','1','2'}
    print(D|E)  #结果为：{'1','p','2','y','3','1'}
    #集合处理方法
    #S.add(x):如果x不在集合S中，将x增加到S
    #S.discard(x):移除S中元素x，如果x不在集合S中，不报错
    #S.remove(x):移除S中元素x，如果x不在集合S中，产生KeyError异常
    #S.clear():移除S中所有元素
    #S.pop():随机返回S的一个元素，更新S，若S为空产生KeyError异常
    #S.copy():返回集合S的一个副本
    #len(S):返回集合S的元素个数
    #x in S:判断S中元素x，x在集合S中，返回true,否则返回False
    #x not in S:判断S中元素x，x不在集合S中，返回True,否则返回False
    #set(x):将其他类型变量x转变为集合类型
    #例：
    F={"p","y",123}
    for item in F:
        print(item,end="")
    #结果为：p123y
    print(F)
    try:
        while True:
            print(F.pop(),end="")
    except:
        pass
    #集合类型应用场景
    #包含关系
    print("p"in {"p","y",123})
    print({"p","y"}>={"p","y",123})
    #数据去重：集合类型所有元素无重复
    ls=["p","p","y","y",123]
    s=set(ls)
    print(s)    #利用了集合无重复元素的特点
    lt=list(s)  #还可以将集合转换为列表
    print(lt)

序列类型

def array():
    #序列类型的定义：序列是具有先后关系的一组元素
    #序列是一维元素向量，元素类型可以不同
    #类似数学元素序列：s0,s1,.....,sn-1
    #元素间由序号引导，通过下标访问序列的特定元素
    #序列分为字符串类型，元组类型，列表类型三个基本类型
    #序列处理函数及方法
    #序列类型通用操作符
    #x in s:如果x是序列s的元素，返回True,否则返回False
    #x not in s: 如果x是序列s的元素，返回False,否则返回True
    #s+t:连接两个序列s和t
    #s*n或n*s:将序列s复制n次
    #s[i]:索引：返回s中的第i个元素，i是序列的序号
    #s[i:j]或s[i:j:k]:切片，返回序列s中第i到j以k为步长的元素子序列
    #操作实例
    ls1=["python",123,".io"]
    print(ls1[::-1])
    s="python123.io"
    print(s[::-1])
    #序列类型通用函数和办法
    #len(s):返回序列s的长度，即元素个数
    #min(s):返回序列s的最小元素，s中元素需要可比较
    #max(s):返回序列s的最大元素，s中元素需要可比较
    #s.index(x)或s.index(x,i,j):返回序列s从i开始到j位置中第一次出现元素x的位置
    #s.count(x):返回序列s中出现x的总次数
    #实例
    print(len(ls1))
    print(max(s))

元组类型及操作

    #定义：元组是序列类型的一种扩展
    #元组是一种序列类型，一但创建就不能被修改
    #使用小括号()或tuple()创建，元组建用逗号，分隔
    #可以使用或不适用小括号
    #例
    creature="cat","dog","tiger","human"
    print(creature)
    color=(0x001100,"blue",creature)
    print(color)
    #元组类型的操作：继承了序列的全部通用操作
    #元组因为创建后不能修改，因此没有特殊操作
    #使用或不使用小括号
    print(creature[::-1])
    print(color[-1][2])
    #列表类型及操作
    #定义：列表是序列类型的一种扩展，创建后可以随意被修改
    #使用方括号[]或list()创建，元素间用逗号，分隔
    #列表中各元素类型可以不同，无长度限制
    #例
    ls2=["cat","dog","tiger",1024]
    print(ls2)
    lt2=ls2       #方括号[]真正创建一个列表，赋值仅起传递作用
    print(lt2)
    #函数类型操作函数和方法
    #ls[i]=x:替换列表ls第i元素为x
    #ls[i:j:k]=lt:用列表lt替换ls切片后所对应元素子列表
    # del ls[i]:删除列表ls中的第i元素
    #del ls[i:j:k]:删除列表ls中第i到j以k为步长的元素
    #ls+=lt:更新列表ls，将列表lt元素增加到列表ls中
    #ls*=n:更新列表ls，其元素重复n次
    ls2[1:2]=[1,2,3,4]
    print(ls2)
    del ls2[::3]
    print(ls2)
    print(ls2*2)

列表类型操作函数和方法

    #ls.append(x):在列表ls最后增加一个元素x
    #ls.clear():删除列表ls中所有元素
    #ls.insert(i,x):在列表ls的第i位置增加元素x
    #ls.pop(i):将列表ls中第i位置元素取出并删除该元素
    #ls.remove(x):将列表ls中出现的第一个元素x删除
    #ls.reverse():将列表ls中的元素反转
    #例
    ls3=["cat","dog","tiger",1024]
    ls3.append(1234)
    print(ls3)
    ls3.insert(3, "human")
    print(ls3)
    ls3.reverse()
    print(ls3)
    ls3.remove("human")
    print(ls3)
    lt=[]
    lt+=ls3
    print(lt)
    #元组遍历
    # for item in ls1:
    #     return
    # for item in tp:
    #如果不希望数据被程序改变，转换为元组类型
    lt=tuple(ls3)
    print(lt)

字典类型

def dic():
    #映射：一种键（索引）和值（数据）的对应
    #字典类型是"映射"的体现
    #键值对：键是数据索引的扩展
    #采用大括号{}和dic()创建，键值对用冒号:表示
    #格式：
    #{<键1>:<值1>,<键2>:<值2>,...,<键n>:<值n>}
    #在字典变量中通过键获得值
    #<字典变量>={<键1>:<值1>,<键2>:<值2>,...,<键n>:<值n>}
    #<值>=<字典变量>[<键>]
    #<字典变量>[<键>]=<值>
    #[]用来向字典变量中索引或增加元素
    #字典类型定义和使用
    d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
    print(d)
    print(d["中国"])
    de={};type(de)
    #字典处理函数及方法
    #del d[k]:删除字典d中键k对应的数据值
    #k in d: 判断键k是否在字典d中，如果在返回True,否则False
    #d.keys():返回字典d中所有的键信息
    #d.values():返回字典d中所有的值信息
    #d.items():返回字典d中所有的键值对信息
    print(d.keys())
    print( "中国"in d)
    print(d.values())
    print(d.items())
    #d.get(k,<default>):键k存在，则返回相应值，不在则返回<default>值
    #d.pop(k,<default>):键k存在，则取出返回值，不在则返回<default>值
    #d.popitem():随机从字典d中取出一个键值对，以元组形式返回
    #d.clear():删除所有的键值对
    #len(d):返回字典d中元素的个数
    print(d.get("中国","依兰"))
    print(d.get("王权","东方"))
    print(d.popitem())
    #元素遍历
    #for k in d: