python入门(三)列表、元组、range()、字典

3.4 列表(list)

  1. 列表简介:列表(list)是处理一组有序项目的数据结构。用方括号[]表示。可以进行添加,删除,替换,搜索操作。是可变的数据类型。列表可以嵌套和支持索引。

    name=[12,"哈哈"]#定义一个列表
    print(id(name[0]))#id获取对象的内存地址
    
    s="alex"
    s="wusir"
    s[0]="b"#报错 字符串是不可变的量
  2. 列表的增:append、insert、extend
    • #append:在列表末尾添加一个元素
      
      name=[12,"哈哈"]
      name.append(True)#在列表的末尾添加一个元素
      print(name)
      #结果为:12 哈哈  True
      
      #insert:指定索引进行插入
      name=[12,"哈哈"]
      name.insert(0,True)#insert(索引,要添加的元素);写上要添加的位置(索引值)和要添加的元素
      print(name)
      #结果为: True 12 哈哈
      
      #extend:在列表末尾追加可迭代对象中的元素来扩展列表
      name=[12,"哈哈"]
      name.extend("1123")#extend()方法中填写可迭代对象( 可迭代对象:字符串、列表、元祖、字典;不可迭代对象:数字和布尔型)
      print(name)
      #结果为:"12" "哈哈" "1" "1" "2" "3"
      name.extend([11,22])
      print(a)
      #结果为: "12" "哈哈" "11" "22"
  3. 列表的删:del、remove、pop、clear
    • #pop:默认删除最后一个;可以通过指定索引进行删除
      name=[11,22]
      name.pop()#默认删除最后一个
      print(name)
      #结果为:"11"
      name.pop(0)#指定索引进行删除
      print(name)
      #结果为:"22"
      
      #remove:通过元素名字进行删除
      name=["haha",True]
      name.remove("haha")#remove()括号中写要移除的元素
      print(name)
      #结果为: True
      
      #del:可以通过索引删除、切片删除、步长删除
      #通过索引删除
      name=[11,22,33,44,55,66]
      del name[0]#填写需要删除的索引
      print(name)
      #结果为:"22" "33" "44" "55" "66"
      
      #通过切片删除
      name=[11,22,33,44,55,66]
      del name[0:3]#删除索引0-2的元素
      print (name)
      #结果为:"44" "55" "66"
      
      #通过步长删除
      name=[11,22,33,44,55,66]
      del name[0:3:2]#删除索引0-2的元素,步长为2
      print(name)
      #结果为:"22" "44" "55" "66"
      
      #clear:清空列表
      name=[11,22,33,44,55,66]
      name.clear()
      print(name)
      #结果为[]
  4. 列表的改
    #通过索引改
    name=[11,22,33,44,55,66]
    name[0]=1
    print(name)
    #结果为1 22 33 44 55 66
    
    #通过切片改
    name=[11,22,33,44,55,66]
    name[0:3]="12345"#通过切片改,改变的值为可迭代对象,进行循环迭代,步长为1 不用一一对应
    print(name)
    #结果为:1 2 3 4 5 44 55 66
    
    #通过步长改
    name=[11,22,33,44,55,66]
    name[0:3:2]="12"#步长不为1的必须用一一对应,多一个也不行,少一个也不行
    print(name)
    #结果为:1 22 2 44 55 66
  5. 列表的查
    • name=[11,22,33,44,55,66]
      for x in name:
         print(x)
  6. 列表的嵌套
    • name=[1,"alex","春生","小东北","渣弟",["大黑哥",["常鑫",["自行车"],"大煎饼","掉井盖","三金"],"冯强","海峰",["太白金星","女神","吴超",["肖锋"]]]
      #假如要输出 肖锋的值
      print(name[5][4][3][0])
      #不管什么类型进行切片的时候获取到的都是源数据类型

3.5 元组(tuple)

  1. 元组(touple)简介:有序、元素不可变、支持索引;元组用来存储一些重要的信息;元组在配置文件中会使用;元组就是不可变的列表
  2. 定义方式:
    tu=(1,"alex",True,"大黑哥",[1,2,3])

3.6 range()方法

  1. range():范围

    • print(list(range(0,10)))#前闭后开
      #range()与列表切片不同的是:range()起始位置 终止位置 步长用逗号隔开;列表切片则用:隔开
      print(list(range(0,10,1))) #步长不写得时候默认为1  [0:10:1]
      print(list(range(10,-2,-1))) #步长不写得时候默认为1  [10:-2:-1]
      print(list(range(10))) #步长不写得时候默认为1  [:10]
    • 错误实例:
    • while range(0,10):#列表不为空为True 所以是死循环
         print(1)
    • python2和python3的区别
    • # python3 中的range是一个可迭代对象 写得是怎样的打印的时候就是怎样
      # 获取成列表:list(range(0,10)) 顾头不顾尾
      # python2 中的range返回的是一个列表

3.7 字典(dict)

  1. 字典简介:字典是无序的,可变的数据类型;用于存储数据,存储大量数据 字典要比列表快,将数据数据之间关联
  2. 定义一个字典:
    dic={1:1223,"haha":True,True:False}#字典中逗号分隔的叫做一个元素 1(键) 1223(值)
    #字典的键:为不可变的数据类型
    #可哈希的---不可变的数据类型---避免哈希冲突 使用了开放寻址法
    #不可哈希---可变的数据类型
    #字典的键:要去唯一----如果有重复将后面的覆盖前面的值
    
    #字典的值:可以任意
  3. 字典的增、删、改、查
    • 增:setdefault()
    • #增
      dic={"常鑫":10,"李文虎":80,"张宇":100}#定义一个字典
      dic["haha"]=10#暴力添加 如果该键不存在 则为添加;存在则将值进行修改
      print(dic)
      #结果为:{"常鑫":10,"李文虎":80,"张宇":100}
      dic["常鑫"]=1#进行修改
      print(dic)
      #结果为:{"常鑫":1,"李文虎":80,"张宇":100}
      
      dic={"常鑫":10,"李文虎":80,"张宇":100}#定义一个字典
      dic.setdefault("haha",11)#如果键不存在则进行添加
      dic.setdefault("常鑫":1)#如果键存在则不进行操作
      print(dic)
      #结果为:{"常鑫":10,"李文虎":80,"张宇":100,"haha":1}
      
    • 删:del、pop()
    • #删
      dic={"常鑫":10,"李文虎":80,"张宇":100}#定义一个字典
      del dic["常鑫"]#通过字典的键进行删除
      print(dic)#结果为:{"李文虎":80,"张宇":100}
      
      dic={"常鑫":10,"李文虎":80,"张宇":100}#定义一个字典
      dic.pop("常鑫")#通过字典的键进行删除
      print(dic)#结果为{李文虎":80,"张宇":100}
    • 改:update()
    • #改
      dic={"常鑫":10,"李文虎":80,"张宇":100}#定义一个字典
      dic["常鑫"]=3#如果该键不存在 则为添加;存在则将值进行修改
      print(dic)#结果为{"常鑫":3,"李文虎":80,"张宇":100}
      
      dic={"常鑫":10,"李文虎":80,"张宇":100}#定义一个字典
      dic1={"常鑫":1,"haha":11}
      dic.update(dic1)#update括号中的字典级别高于update前面的字典 键无则添加,有则修改
      #结果为:{"常鑫":1,"李文虎":80,"张宇":100,"haha":1}
    • dic={"常鑫":10,"李文虎":80,"张宇":100}#定义一个字典
      for x in dic:
          print(x)#输出每个键值
      #结果为:
      #常鑫
      #李文虎
      #张宇
      
      #获取值
      dic={"常鑫":10,"李文虎":80,"张宇":100}#定义一个字典
      print(dic.get("张宇"))#获取字典中键为"张宇"的值并输出
      #结果为:100
      print(dic.get("haha"))#获取字典中键为"haha"的值并输出,不存在该键,返回None并输出
      
      print(dic["张宇"])#获取字典中键为"张宇"的值并输出
      #结果为100
      print(dic.get("haha"))#获取字典中键为"haha"的值并输出,不存在该键,报错
  4. 其他操作:
    • dic={"常鑫":10,"李文虎":80,"张宇":100}#定义一个字典
      
      #获取键
      print(dic.keys())#获取该字典所有键并输出;高仿列表支持for循环,不支持索引
      #结果为:dict_keys(['常鑫', '李文虎', '张宇'])
      
      for x in dic:
          print(x,dic[x])
          print(x,dic.get(x))
      #输出该字典的键和值
      #结果为:
      #常鑫 10
      #李文虎 80
      #张宇 100
      
      #获取值
      print(dic.values())#获取该字典所有值并输出
      #结果为:dict_values([10,80,100])
      
      #获取键和值
      print(dic.items())#输出所有的键和值
      #结果为:
      #常鑫 10
      #李文虎 80
      #张宇 100
  5. 解构
    • a,b=10,20
      print(a,b)#等号后边的值和前面的变量名要一一对应
      #结果为10 20
      
      a=10,12
      print(a)#本质上a是一个元组
      
      a,b="23"
      print(a,b)#结果为2 3
      
      a.b={1:a,3:b}
      print(a,b)
      #结果为1 3
      
      dic={"常鑫":10,"李文虎":80,"张宇":100}#定义一个字典
      for i in dic.items():
          print(i)
      #结果为:
      #('常鑫', 10)
      #('李文虎', 80)
      #('张宇', 100)
      
      dic={"常鑫":10,"李文虎":80,"张宇":100}#定义一个字典
      for x,y in dic.items():
          print(x,y)
      #结果为:
      #常鑫 10
      #李文虎 80
      #张宇 100
  6. 字典的嵌套
    • dic={1005:{"常鑫":["大黑哥","大烧饼","吃大煎饼","肉夹馍","自行车","井盖",]}}
      #找到井盖并输出
      print(dic[1005]["常鑫"][5])

原文地址:https://www.cnblogs.com/zhangdadayou/p/11171843.html

时间: 2024-11-09 08:05:43

python入门(三)列表、元组、range()、字典的相关文章

python基础三(列表和元组)

数据结构:数据结构是以某种方式(如通过编号)组合起来的数据元素集合.在python中,最基本的数据结构为序列,序列中每个元素都有编号从0开始. 1.序列概述:?python内置了许多种序列,列表.元组.字符串等.?列表和元组的不同在于,列表是可以修改的,而元组不可以,这意味着列表用于需要中途添加元素的情形,而元组适用于禁止修改元素的情形. 1.1.创建列表 假设你现在需要一个东西来储存多个名字,那么用列表正合适 list_name = ["王晓明","李二"] #所

Python基础【数据结构:列表 | 元组 | 集合 | 字典】

序列 序列是Python中最基本的数据结构.包括字符串,列表,元组,Unicode字符串,buffer对象,xrange对象.序列中的每个元素都分配一个数字,即它的索引第一个索引是0,第二个索引是1,依此类推. 列表和元组 列表一个方括号内的逗号分隔值列表中可以存放不同的数据类型. 例:[1,1.2,True,'str',[2,False]]元组与列表类似,不同之处在于元组的元素不能修改.元组使用小括号,列表使用方括号. 例:(1,1.2,True,'str',[2,False]) 列表和元组的

[Python日记-2]列表-元组-字典-if-for

今天学习了列表,元组,字典相关知识,真的琐碎.我应该是学了好几遍了,刚开始是充满激情的,学到一个方法就迫不及待地去尝试,现在也平和了.好了,总结下. 1. 列表 Python中用方括号([])来表示列表,并用逗号来分隔其中的元素.要访问列表元素,列表的名称[索引]. 索引可以是负值,如将索引指定为-1,可让Python返回最后一个列表元素.可以在不明确列表长度的情况下,访问最后的元素. 1.1 列表中添加元素的方法: 1 Lis = [] 2 3 Lis.title() #使列表中每个元素的首字

python入门学习-列表和元组(1)

数据结构是通过某种方式(例如对元素进行编号)组织在一起的数据元素的集合.这些数据元素可以是数字或者字符,甚至可以是其他数据结构. 在python中,最基本的数据结构是序列(sequence).序列中的每个元素被分配一个序号--即元素的位置,也称为索引.第一个索引是0,第二个是1,以此类推. 1.1序列概览 python包含6种內建的序列,最常用的两种类型是:列表和元组.其他的內建序列类型有字符串.Unicode字符串.buffer对象和xrang对象. 列表和元组主要区别在于,列表可以修改,元组

Python数据结构之列表元组字典的用法

数据结构的含义 在学习数据结构之前,我们先来了解下数据结构的含义.数据结构是通过某种方式(例如对元素进行编号)组织在一起的数据元素的集合,这些数据元素可以是数字或者字符,甚至可以是其他数据结构.在Python语言中,最基本的数据结构是序列(sequence).序列中的每个元素被分配一个序号----即元素的位置,称为索引或下标,索引从0开始递增. 典型的序列包括列表.元组和字符串.其中,列表是可变的(可修改),而元组和字符串是不可变的(一旦创建了就是固定的).列表.元组和字符串也是较常用的数据结构

python入门12 列表

列表使用率较高,方法也多. 列表的定义 #coding:utf-8 #/usr/bin/python """ 2018-11-10 dinghanhua 列表 """ '''列表 可变数据类型 序列的一种 使用率比较高''' li = [1,2,3,4] li2 = ['mon','tue','wed','thu','fri','sat','sun'] li3 = [(1,2),'string',['list']] li4 = [[1,'appl

Python成长笔记 - 基础篇 (三)python列表元组、字典、集合

本节内容 列表.元组操作 字符串操作 字典操作 集合操作 文件操作 字符编码与转码   一.列表和元组的操作 列表是我们最以后最常用的数据类型之一,通过列表可以对数据实现最方便的存储.修改等操作 定义列表 names = ["Wang","HouZi1","NiuNiu","ZhouYi","HouZi2",[1,2]] 可以通过列表角标的方式去获得list中的值 print(names)print(nam

python列表元组集合字典

一.列表 1.列表格式 list1 = ['Google', 'Runoob', 1997, 2000]; list2 = [1, 2, 3, 4, 5 ]; 2.列表访问 list1[0]:Google list2[1:5]:[2,3,4,5] 3.l列表更新 list2[2]=新的值 del list[2] 删除第三个元素 4.列表操作符 len(list1)=list1长度 [1,2,3]+[4,5,6]=[1,2,3,4,5,6] ["hi"]*4=["hi"

python 数据类型 变量 列表 元组 字典 集合

Python中,能够直接处理的数据类型有以下几种: 整数 Python可以处理任意大小的整数,当然包括负整数,在程序中的表示方法和数学上的写法一模一样,例如:1,100,-8080,0,等等. 计算机由于使用二进制,所以,有时候用十六进制表示整数比较方便,十六进制用0x前缀和0-9,a-f表示,例如:0xff00,0xa5b4c3d2,等等. 浮点数 浮点数也就是小数,之所以称为浮点数,是因为按照科学记数法表示时,一个浮点数的小数点位置是可变的,比如,1.23x109和12.3x108是完全相等

python入门之列表和元组

获得更多资料欢迎进入我的网站或者 csdn或者博客园 前面一张主要学习了Python的安装,以及第一个程序helloword的编写,以及简单的输入和输出函数 序列 ?这章主要介绍的是列表和元组,而列表和元组是序列的六种内型中的两种,主要区别.列表可以修改,而元组不能.而序列很好用比如要操作一组人的名字和年龄可以这样: peace=['peace one',23] rong=['sisi',22] data=[peace,rong] data [['peace one',23],['sisi',2