精华内容
下载资源
问答
  • Python基础--列表使用

    2020-12-18 14:34:47
    列表中元素的类型可以不相同,它⽀持数字,字符串甚⾄可以包含列表(所谓嵌套)。 列表是写在⽅括号 [] 之间、⽤逗号分隔开的元素列表。 1、List写在⽅括号之间,元素⽤逗号隔开。 2、和字符串⼀样,list可以被索引...


    List(列表) 是 Python 中使⽤最频繁的数据类型。
    列表可以完成⼤多数集合类的数据结构实现。列表中元素的类型可以不相同,它⽀持数字,字符串甚⾄可以包含列表(所谓嵌套)。
    列表是写在⽅括号 [] 之间、⽤逗号分隔开的元素列表。
    1、List写在⽅括号之间,元素⽤逗号隔开。
    2、和字符串⼀样,list可以被索引和切⽚。
    3、List可以使⽤+操作符进⾏拼接。
    4、List中的元素是可以改变的。
    列表对 + 和 * 的操作符与字符串相似。+ 号⽤于组合列表,* 号⽤于重复列表。

    1、列表相加

    # 定义列表
    qingdao = ['msj', 'mjk', 'hjr']
    qishun = ['lxs', 'xpx', 2020, 33]
    # 输出列表
    print("qingdao:", qingdao)
    print("qishun:", qishun)
    # 列表相加
    allstr = qingdao + qishun
    print("allstr = qingdao+qishun:\n", qingdao + qishun)
    print("len(qingdao+qishun):", len(qingdao+qishun))
    

    运行结果
    qingdao: [‘msj’, ‘mjk’, ‘hjr’]
    qishun: [‘lxs’, ‘xpx’, 2020, 33]
    allstr = qingdao+qishun:
    [‘msj’, ‘mjk’, ‘hjr’, ‘lxs’, ‘xpx’, 2020, 33]
    len(qingdao+qishun): 7

    2、列表重复

    # 列表可以重复,重复30次
    print("\n列表使用\n"+"-"*30)
    

    运行结果
    列表使用
    .------------------------------

    3、列表的遍历

    print("\nallstr的遍历:" + "\n" + "-"*30)
    # allstr 在上例已定义
    for i in allstr:
        print(i, end=" ")
    

    运行结果
    allstr的遍历:
    .------------------------------
    msj mjk hjr lxs xpx 2020 33

    3、列表元素访问

    print("\n访问第三个元素allstr[2]: ", allstr[2])
    print("访问最后个元素allstr[-1]: ", allstr[-1])
    print("取1-2个元素开始allstr[:2]: ", allstr[:2])
    print("取3个元素开始allstr[2:]: ", allstr[2:])
    print("max(allstr): ", allstr[2:])
    

    运行结果
    访问第三个元素allstr[2]: hjr
    访问最后个元素allstr[-1]: 33
    取1-2个元素开始allstr[:2]: [‘msj’, ‘mjk’]
    取3个元素开始allstr[2:]: [‘hjr’, ‘lxs’, ‘xpx’, 2020, 33]
    max(allstr): [‘hjr’, ‘lxs’, ‘xpx’, 2020, 33]

    4、列表方法

    4.1、添加元素到列表

    #列表方法
    print("修改前的列表: ",qishun)
    # 尾部增加新元素
    qishun.append(2020)
    print("修改后的列表qishun:", qishun)
    # 统计某个元素出现的次数
    print("2020出现的次数:", qishun.count(2020))
    

    运行结果
    修改前的列表: [‘lxs’, ‘xpx’, 2020, 33]
    修改后的列表qishun: [‘lxs’, ‘xpx’, 2020, 33, 2020]
    2020出现的次数: 2

    4.2、列表追添加元素

    # 在列表末尾次性追加另一个序列中的多个值
    print("操作前的列表: ",qishun)
    list_add = [10, 10, 20, 10]
    qishun.extend(list_add)
    print("操作后的列表:", qishun)
    # 从列表中找出某个值第一个匹配项的索引位置
    print("qishun.index(obj):", qishun.index(2020))
    # 将对象在index位置插入列表元素
    qishun.insert(1,'Test')
    print("qishun.insert(index,obj):", qishun)
    
    

    运行结果
    操作前的列表: [‘lxs’, ‘xpx’, 2020, 33, 2020]
    操作后的列表: [‘lxs’, ‘xpx’, 2020, 33, 2020, 10, 10, 20, 10]
    qishun.index(obj): 2
    qishun.insert(index,obj): [‘lxs’, ‘Test’, ‘xpx’, 2020, 33, 2020, 10, 10, 20, 10]

    4.3、列表元素的移除

    # 移除默认最后的元素
    qishun.pop()
    print("qishun.pop():\n", qishun)
    # 移除指定位置的元素
    qishun.pop(1)
    print("qishun.pop(index):\n", qishun)
    # 移除列表中某个元素的第一个匹配项
    print("qishun:", qishun)
    qishun.remove(10)
    print("qishun.remove(obj):\n", qishun)
    
    

    运行结果
    qishun.pop():
    [‘lxs’, ‘Test’, ‘xpx’, 2020, 33, 2020, 10, 10, 20]
    qishun.pop(index):
    [‘lxs’, ‘xpx’, 2020, 33, 2020, 10, 10, 20]
    qishun: [‘lxs’, ‘xpx’, 2020, 33, 2020, 10, 10, 20]
    qishun.remove(obj):
    [‘lxs’, ‘xpx’, 2020, 33, 2020, 10, 20]

    4.4、列表反转、排序

    # 反转列表
    print("反转前:", qishun)
    qishun.reverse()
    print("反转列表qishun.reverse():\n", qishun)
    #移除最后两个元素
    for i in range(2):
        qishun.pop()
    print("移除两个元素后的新列表:", qishun)
    qishun.sort()
    print("列表排序(升序)qishun.sort():\n", qishun)
    qishun.sort(reverse=True)
    print("列表排序(降序)qishun.sort(reverse = True):\n", qishun)
    shun = qishun.copy()
    print("qishun.copy复制列表,shun:", shun)
    qishun.clear()
    print("清空列表qishun.sort():", qishun)
    print("复制后的列表shun不受影响:", shun)
    

    运行结果
    反转前: [‘lxs’, ‘xpx’, 2020, 33, 2020, 10, 20]
    反转列表qishun.reverse():
    [20, 10, 2020, 33, 2020, ‘xpx’, ‘lxs’]
    移除两个元素后的新列表: [20, 10, 2020, 33, 2020]
    列表排序(升序)qishun.sort():
    [10, 20, 33, 2020, 2020]
    列表排序(降序)qishun.sort(reverse = True):
    [2020, 2020, 33, 20, 10]
    qishun.copy复制列表,shun: [2020, 2020, 33, 20, 10]
    清空列表qishun.sort(): []
    复制后的列表shun不受影响: [2020, 2020, 33, 20, 10]

    展开全文
  • 列表

    2020-07-13 10:38:49
    列表可以嵌套列表列表可以嵌套字典;列表可以嵌套任何东西 列表的元素需要具有相同的类型 使用索引来访问元素(第一个元素的索引编号为0) 可切片 常用示例 #!/usr/bin/env python #_*_coding:utf-8_*_ __author_...

    列表具有以下特征:

    1. 可以用list()函数或者方括号[]创建,元素之间用逗号分隔。
    2. 列表可以嵌套列表;列表可以嵌套字典;列表可以嵌套任何东西
    3. 列表的元素不需要具有相同的类型
    4. 使用索引来访问元素(第一个元素的索引编号为0)
    5. 可切片

    常用示例

    #!/usr/bin/env python
    #_*_coding:utf-8_*_
    __author__ = 'Administrator'
    list1 = ["user1","user2","user3","user4","user5"]   #展示使用方括号定义列表list1
    list2 = [0,1,2,3,"www",[5,6,7,"hhh"]]  #展示使用方括号定义列表list2,列表中的元素不需要具备相同的类型;且列表中可以包含列表
    list3 = list(["host1","host2","host3","host4"])    #展示使用list()函数定义列表list3
    
    print(list1)               #打印列表的全部内容
    print(list1[0],list1[2])   #指定具体位置
    print(list1[1:3])          #切片取数据;1为起始位置,3为结束位置;取出来的数据,包含起始位置的数据,不包含结束位置的数据
    print(list1[-1])           # 切片取数据;-1代表从右边开始数,也就是从末尾开始取出末尾第一的数据
    print(list1[-2:])          #切片取数据;从后边开始取出最后的两个值,因为是从左往右数的所以-2在前边,-2:表示倒数第二到末尾的所有数据
    print(list1[0:3])          #切片取数据;取出前3列
    print(list1[:3])           #切片取数据;取出前3列,:前边是0的话是可以忽略的
    print(list1[0:-1:2])         #列表的步长切片,0表示起始位置,-1表示结束位置,也就是列表的最后一列,2表示步长
    
    list1.append("user6")       #列表的追加,这样会追加到最后一列
    list1.insert(0,"user0")     #列表的插入,0表示你要占用的位置,user0表示你要插入的内容,原来的列表内容索引编号0开始,全部后移
    list1[0] = "aaaaa"          #列表的修改,修改的话直接指定具体位置,然后赋予新的值即可
    
    del list1[0]                 #列表内容的删除,列表内容的删除由3种方法,(第一种:指定删除位置)
    list1.remove("user5")        #列表内容的删除,列表内容的删除由3种方法,(第二种:指定删除内容)
    list1.pop()                  #列表内容的删除,列表内容的删除由3种方法,(第三种:pop pop不输入下标,默认删除最后一列元素)
    list1.pop(3)                 #列表内容的删除,列表内容的删除由3种方法,(第三种:pop 输入下表的话,与del list1[0]就一样了)
    
    del list1                    #列表的删除
    
    print(list1.index("user3"))   #查询某些字符的索引位置,如果查询的字符不在列表之内,就会报 'XXXXX' is not in list的错误
    print(list1.count("user3"))   #查询列表中某些字符出现的次数,显示结果为1,则表示user3在列表中出现1次;显示结果为2,则表示user3在列表中出现2次;依此类推
    list1.clear()                   #清空列表,显示的结果为一对儿方括号[]
    list1.reverse()                  #列表反转,列表项反向显示
    list1.sort()                       #列表的排序,默认的排序规则从前往后为:特殊符号--数字--大写---小写
    list1.extend(list3)                #列表的合并,这样列表list1就会多出list3的内容,list3的内容补充到最后
    

    列表中可以包含列表

    #!/usr/bin/env python
    #_*_coding:utf-8_*_
    __author__ = 'Administrator'
    
    names = ["user1","user2",["子列表1","子列表2"],"user3","user4","user5"]   # 创建列表names,包含子列表
    print(names[2][0])
    

    我们要取出子列表中的字符"子列表1"可以使用names[2][0],意思是先找到最外层列表的第二个位置,再找到子列表的第一个位置。

    当然也可以多层列表嵌套使用,如下代码示例

    #!/usr/bin/env python
    #_*_coding:utf-8_*_
    __author__ = 'Administrator'
    
    names = ["user1","user2",["子列表1","子列表2",["111","222"]],"user3","user4","user5"]
    

    要想取出字符串儿"111",可以使用print(names[2][2][0])。意思是先定位到第一层的第2个位置,然后定位到第二层的第2个位置,最后定位到第三层的第1个位置。

    列表与for循环的结合使用

    #!/usr/bin/env python
    #_*_coding:utf-8_*_
    __author__ = 'Administrator'
    list1 = ["user1","user2","user3","user4","user5"]
    for i in list1:
        print(i)
    

    运行结果:
    在这里插入图片描述
    示例1:列表的复制(单层列表)

    #!/usr/bin/env python
    #_*_coding:utf-8_*_
    __author__ = 'Administrator'
    
    names = ["user1","user2","user3","user4","user5"]   # 创建列表names
    names2 = names.copy() # 复制列表names然后赋值给names2
    names[0] = "用户1"  #修改name2列表第一列的内容
    print(names)
    print(names2)
    

    运行结果:
    修改复制的源,不会影响复制的变量,这只是浅copy,只copy列表的第一层;对于嵌套使用的子列表只是cpoy了一个内存地址,所以这里叫浅copy
    在这里插入图片描述
    示例2:列表的复制(多层列表)

    #!/usr/bin/env python
    #_*_coding:utf-8_*_
    __author__ = 'Administrator'
    
    names = ["user1","user2",["子列表1","子列表2"],"user3","user4","user5"]   # 创建列表names,包含子列表
    names2 = names.copy()  #复制names赋值给变量names2
    names[0] = "用户1"    #修改外层列表的内容
    names2[2][0] = "子列表111"  #修改子列表的内容
    print(names)
    print(names2)
    

    运行结果:
    修改外层列表names[1]目标copy的names2不会改变
    但是修改子列表names2[2][0] 列表names[2][0]也会跟着改变
    在这里插入图片描述

    示例3:列表的完全copy
    从上边的两个实例可以看出.copy()在遇到嵌套列表的时候,不好用了(复制的列表与源列表之间相互影响),这就是浅copy的缺点,对于浅cop来讲,只是将第一层列表完全复制了(在内存中分配了新的指针),但是对于子列表来讲并没有完全复制(复制目标的子列表与复制源的子列表指向的指针相同),所以出现了示例2的问题。
    那么我们想完全复制一个列表怎么办呢?(完全复制指的是包含列表与子列表),这就需要用到一个独立的copy模块,使用独立copy模块的deepcopy()方法,也就是深copy

    #!/usr/bin/env python
    #_*_coding:utf-8_*_
    __author__ = 'Administrator'
    import copy
    names = ["user1","user2",["子列表1","子列表2"],"user3","user4","user5"]   # 创建列表names,包含子列表
    names2 = copy.deepcopy(names)  #复制names赋值给变量names2
    names[0] = "用户1"    #修改外层列表的内容
    names2[2][0] = "子列表111"  #修改子列表的内容
    print(names)
    print(names2)
    

    运行结果:
    可以看到子列表的修改不会相互影响了
    在这里插入图片描述

    但是需要注意的是深copy一定要慎用,比如说你的列表中存了几百万条数据,你用深copy完全复制了一份,那么就会占用完全2份独立的内存空间。大部分情况下我们不需要将列表完全copy。

    展开全文
  • 用于实现View的拖拽操作,列表拖动适用于用户的托起,放下操作,重在内容的移动,拖拽时可以附加拖拽数据,数据分为本地数据LocalState(App内进行拖拽),跨进程数据ClipData(两个App之间进行拖拽);比如添加物品进...

    View.onDragListener(View)

    Api 11引入的工具类,用于实现View的拖拽操作,列表拖动

    适用于用户的托起,放下操作,重在内容的移动,拖拽时可以附加拖拽数据,数据分为本地数据LocalState(App内进行拖拽),跨进程数据ClipData(两个App之间进行拖拽);比如添加物品进购物车

    不需要进行自定义View,使用view.startDrag()/startDragAndDrop()来启动拖拽操作

    通过view.setDragListener()或者重写View的onDragEvent()来监听View的拖拽状态

    拖拽原理:创建一个图层(DragShadowBuilder)在屏幕的最上层,这个图层会随着用户手指的移动而移动

    使用

    开启拖拽

    val clipData = ClipData.newPlainText("name", "drag data")

    ViewCompat.startDragAndDrop(view, clipData, View.DragShadowBuilder(it), "LocalState", 0)

    //或者view.startDragAndDrop()

    val clipData = ClipData.newPlainText("name", "drag data")

    view.startDragAndDrop(clipData, View.DragShadowBuilder(it), "LocalState", 0)

    拖拽监听

    view.setOnDragListener(HDragListener)

    //重写OnDragListener实现拖拽监听

    inner class HDragListener : OnDragListener {

    override fun onDrag(v: View, event: DragEvent): Boolean {

    when (event.action) {

    DragEvent.ACTION_DRAG_STARTED ->{

    //开始拖拽时回调

    }

    DragEvent.ACTION_DRAG_ENTERED ->{

    //拖拽到View的边界内回调(可进行排序操作)

    }

    DragEvent.ACTION_DRAG_ENDED ->{

    //结束拖拽时回调

    }

    }

    return true

    }

    }

    //或者重写View的onDragEvent()实现拖拽监听

    override fun onDragEvent(event: DragEvent): Boolean {

    //当前界面中所有View都会回调这个方法

    }

    ViewDragHelper(ViewGroup)

    2015年 SupportV4 包新增的工具类,主要用于ViewGroup中子View的拖拽操作

    需要开发者在自定义ViewGroup中使用,重写ViewGroup的onInterceptTouchEvent()和onTouchEvent()来接管触摸事件

    拖拽原理:实时修改被拖拽的子View的mLeft,mTop,mRight,mBottom值

    使用:

    自定义Callback实现ViewDragHelper.callback接口,监听拖拽回调

    inner class HDragCallback : ViewDragHelper.Callback() {

    //记录下被托起的View的初始位置

    private var capturedLeft = 0

    private var capturedTop = 0

    /*** 返回true时View可以被拖起来*/

    override fun tryCaptureView(child: View, pointerId: Int): Boolean {

    return true

    }

    override fun clampViewPositionHorizontal(child: View, left: Int, dx: Int): Int {

    return left //水平偏移

    }

    override fun clampViewPositionVertical(child: View, top: Int, dy: Int): Int {

    return top //垂直偏移

    }

    /*** View被拖起时回调*/

    override fun onViewCaptured(capturedChild: View, activePointerId: Int) {

    capturedChild.elevation = elevation + 1

    capturedLeft = capturedChild.left

    capturedTop = capturedChild.top

    }

    /*** 拖拽状态改变时回调*/

    override fun onViewDragStateChanged(state: Int) {

    if (state == ViewDragHelper.STATE_IDLE) {

    val capturedView = mDragHelper.capturedView!!

    capturedView.elevation = capturedView.elevation - 1

    }

    }

    override fun onViewPositionChanged(changedView: View, left: Int, top: Int,dx: Int, dy: Int) {

    //位置改变时回调

    }

    /*** View被松开时回调*/

    override fun onViewReleased(releasedChild: View, xvel: Float, yvel: Float) {

    mDragHelper.settleCapturedViewAt(capturedLeft, capturedTop)

    //更新下一帧的绘制 和computeScroll结合

    postInvalidateOnAnimation()

    }

    }

    重写ViewGroup的onInterceptTouchEvent()和onTouchEvent()来接管触摸事件

    private val mDragHelper by lazy {

    ViewDragHelper.create(this, HDragCallback())

    }

    override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {

    return mDragHelper.shouldInterceptTouchEvent(ev)

    }

    override fun onTouchEvent(event: MotionEvent): Boolean {

    mDragHelper.processTouchEvent(event)

    return true

    }

    //和DragCallback的onViewReleased()相结合,循环绘制每一帧

    override fun computeScroll() {

    if (mDragHelper.continueSettling(true)) {

    ViewCompat.postInvalidateOnAnimation(this)

    }

    }

    嵌套滑动

    不同向嵌套

    onInterceptTouchEvent 父 View 拦截子View

    requestDisallowInterceptTouchEvent() 子 View 阻止父 View 拦截

    同向嵌套

    父 View 会彻底卡住子 View(滑动冲突)

    原因:抢夺条件一致,但父View的onInterceptTouchEvent() 早于子View的dispatchTouchEvent()

    本质上是策略问题:嵌套状态下用户手指滑动,他是想滑谁?

    场景一:NestedScrollView 子View能滑动的时候滑动子View;滑不动的时候滑动父View

    场景二:Google 的样例

    父View展开的时候:

    ​ 上滑:优先滑动父View

    ​ 下滑:滑不动

    父View半展开的时候:

    ​ 上滑:优先滑动父View,滑到父View完全折叠后开始滑动子View

    ​ 下滑:优先滑动父View,滑到父View完全展开后开始滑动子View

    父View折叠的时候:

    ​ 上滑:滑动子View

    ​ 下滑:优先滑动子View,滑到子View顶部后开始滑动父View

    滑动嵌套解决方案: 自定义滑动策略(父View,子View谁来消费滑动事件)

    实现:

    大多数场景下SDk就能解决:ScrollView嵌套问题,换成NestedScrollView

    自己实现:实现 NestedScrollingChild2 接口来实现自定义的嵌套滑动逻辑

    展开全文
  • 一. 定义 1.列表 有关列表的定义: 1.list(列表):一个变量存储了多个信息 2.列表中可存储不同的数据类型 ...如果要修改,可以使用list函数把它转化成列表 - 元组内可存储任意类型 3.集合 有关集合的定义: -

    一. 定义

    1.列表

    有关列表的定义:
    	1.list(列表):一个变量存储了多个信息
    	2.列表中可存储不同的数据类型
    	3.列表中可嵌套列表
    	4.列表中的每个元素都分配了一个位置,一个元素对应一个位置。索引值从0开始
    

    2.元组

    有关元组的定义:
    	 - 元组是一种序列,可使用 小括号() 去界定
    	 - 元组中各元素之间用逗号隔开
    	 - 元组本身是一个不可变的数据类型,没有增删改查。如果要修改,可以使用list函数把它转化成列表
    	 - 元组内可存储任意类型
    
    

    3.集合

    有关集合的定义:
    	 - 集合时一个无序的、元素不可重复数据类型,可使用 大括号{} 去界定;
    	 - 集合中各元素之间用逗号隔开;
    	 - 创建空集合时,必须使用set([]),而不是{}。因为{}时用来创建一个空字典的。
    

    4.字典

    有关字典的定义:
    	 - 字典是一个无序的数据类型,使用print输出时,通常与定义顺序不一致
    	 - 定义字典时,使用{}或dict()。此时就揭示了为什么集合定义空集时不可直接使用大括号,而要使用set([]),因为字典对应的也是大括号。
    	 - 字典的每个键值key=>value对用冒号':'分割;每个键值对之间用逗号','分割。格式为
    	 		d = {key1:value1,key:value2}
    	 	'键值对'引申理解:	
    			1)键一般时唯一的,如果重复最后的一个键值对,则会替换前面的
    			2)值不需要唯一,值可以是任何数据类型,但键必须是不可变的,如字符串、数字或元组
    优势:
    	通过key值查询value值效率特别高,时间复杂度O(1)
    

    二. 对比

    1.数组与列表

    数组 列表
    只能存储同一种数据类型的数据 可以存储多种存储数据类型

    2.元组与列表

    元组 列表
    不可变数据类型(不能增删改) 可变数据类型(可以增删改)

    3.集合与字典

    集合 字典
    存储不重复元素的数据类型(应用于去重) 无序的数据类型
    set([])表示空集 s = {} 表示为一个字典

    4.帮助小技巧

    使用python3时,可以按照如下方法,选择自己要完成的功能。使用Tab键很有利于我们的学习
    在这里插入图片描述
    如果不知道该功能怎么使用,就可以利用help命令进行查找
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 列表中元素类型可以不相同,支持数字,字符串甚至可以包含列表(所谓嵌套) 写在方括号 [] 之间、用逗号分隔开 可以被索引和截取,截取的语法格式:变量[头下标:尾下标] 列表中元素可变 至此,先来个开胃菜 a=['甲...
  • 使用列表、字典之间的相互嵌套可以很容易的实现json数据格式,但是昨天在往列表中装入字典时遇到了问题: 直接使用append方法将字典添加到列表中,如果需要更改字典中的数据,那么列表中的内容也会发生改变,这是...
  • python 列表

    2020-09-26 22:49:37
    列表中元素的类型可以不相同,它支持数字,字符串甚至包含列表(所谓嵌套)。 列表是写在方括号[]之间、用逗号分隔开的元素列表列表索引值以0为开始值,-1为从末尾的开始位置。 列表可以使用+操作符进行拼接,...
  • 列表和超链接

    2020-09-20 09:51:21
    无序列表使用ul标签定义,内部可以嵌套多个li标签(li是列表项)。 ul和li标签都拥有type属性,用于指定列表项目符号。 type的属性值 ①disc(默认值):实心圆 ②circle:空心圆 ③square:实心方块 定义type属性...
  • Python3 列表

    2019-02-05 16:44:17
    列表中元素的类型可以 相同,它支持数字,字符串甚至可以包含列表 列表是写在方括号 [] 之间、用逗号 , 分隔开的元素列表 列表可以 被索引和截取,被截取后返回一个包含所需元素的新列表。 二、访问列表...
  • python之列表

    2020-09-09 22:46:03
    列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表嵌套列表是写在方括号[]之间、用逗号分隔开的元素列表 列表索引值以0为开始值,-1为从末尾的开始位置。列表可以使用+操作符进行拼接,使用*...
  • List(列表

    2019-09-21 23:10:02
    列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表嵌套列表是写在方括号([])之间、用逗号分隔开的元素列表。 和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需元素的新...
  • 列表中的元素类型可以不相同,它支持数字,字符串、元组,集合、字典等甚至包括列表嵌套列表元素的修改: 列表大小没有限制,可以随时修改,元素也可随时修改 a.insert(0,1) 在0位置插入1 修改 a[0]=10 列表
  • 列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。列表是写在方括号[]之间、用逗号分隔开的元素列表。和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需元素的新...
  • python列表(List)学习

    2020-09-07 20:34:16
    列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。 ➢列表是写在方括号[]之间、用逗号分隔开的元素列表。 ➢列表索引值以0为开始值, -1为从末尾的开始位置。 ➢列表可以使用+操作符进行...
  • 【06】列表list

    2020-12-11 19:08:03
    列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。 列表是写在方括号之间、用逗号分隔开的元素列表列表索引值以0为开始值,-1为从末尾的开始位置。 列表可以使用+操作符进行拼接,使用...
  • Python3 列表(List)

    2018-10-20 16:50:30
    列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。 列表是写在方括号 [] 之间、用逗号分隔开的元素列表。 和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需...
  • HTML列表标签 列表标签 定义 给一堆数据添加列表语义,让...ul标签和li标签是一个整体,一般是一起出现的,ul标签里面推荐嵌套li以外的标签,但是li标签里面可以嵌套其他标签,例如h标签p标签等 代码实现如下:
  • 列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。 列表是写在方括号 [] 之间、用逗号分隔开的元素列表。 和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需元素...
  • 列表(list)是python中重要的内置数据类型,列表是包含0个或多个对象引用有序序列,列表的长度和内容均可变,因此列表没有长度限制,一个列表中元素的数据类型可以相同(里面还可以列表,即列表嵌套),所有...
  • 列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。 列表是写在方括号 [ ] 之间、用逗号分隔开的元素列表。 和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需...
  • 列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。 列表是写在方括号([])之间、用逗号分隔开的元素列表。 和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所...
  • 列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套) 2.列表是写在方括号 [ ] 之间、用逗号分隔开的元素列表。 3.列表索引值从0开始,-1为从末尾的开始位置。 4.列表可以使用+操作符进行...
  • 使用列表、字典之间的相互嵌套可以很容易的写出json格式的数据,但是能直接使用*列表.append(字典)*方法将字典添加到列表中,因为每次添加时,添加的字典总会将前几个的数据覆盖掉 例如: list = [{'name': '路人...
  • 列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。 列表是写在方括号 [] 之间、用逗号分隔开的元素列表。 和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需元素...
  • 若调用没有形参的函数,实参列表可以没有,但括号能省略,如果实参列表包含多个参数,则各个参数之间用逗号分开,对于函数中,如果形参包含多个参数,用逗号分开 实参,形参个数要相等,类型要一致,按顺序对应,一一传递 ...
  • python3数据类型之列表

    2018-09-11 16:31:41
    列表使用[]括起来的一个个数据,每个数据之间一逗号分隔。数据分类型,数字、字母、字符串、甚至是列表、字典、元组都可以。任意的列表、字典、元组放在列表、字典、元组中叫做嵌套。如下: #纯数字# >...
  • 使用列表、字典之间的相互嵌套可以很容易的实现json数据格式,但是昨天在往列表中装入字典时遇到了问题: 直接使用append方法将字典添加到列表中,如果需要更改字典中的数据,那么列表中的内容也会发生改变,这是...
  • - 列表可以完成大多数集合类的数据结构实现,列表中的元素的类型可以不相同,它支持数字、字符串甚至可以包含列表,也就是列表嵌套 1 索引和切片 - 列表同字符串一样,有索引也可以切片,只不过切片得到的是一个...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 172
精华内容 68
关键字:

列表之间不可以嵌套使用