精华内容
下载资源
问答
  • 2020-03-10 16:59:03

    python常用内置数据类型的总结:
    1.形式:
    列表list:[1,2,3] [a,b,c] [‘myss’,{2},(1,3),[‘c’,2],{65:‘A’}]
    【所有元素放在一对方括号中,元素之间使用逗号分隔,其中的元素可以是任意类型】
    元组tuple:(1,2,3) (1,)
    【所有元素放在一对圆括号中,元素之间使用逗号分隔,元组中只有一个元素时后面的逗号不能省略】
    字典dict:{‘a’:97,‘b’:98,‘c’:99,‘d’:100} {1:‘a’:2:‘b’}
    【所有元素放在一对大括号中,元素之间使用逗号分隔,元素形式为“键:值”,其中“键”不允许重复并且必须为不可变类型,“值”可以是任意类型的数据】
    集合set:{‘a’,‘b’,‘c’}
    【所有元素放在一对大括号中,元素之间使用逗号分隔,元素不允许重复且必须为不可变类型;集合中只能包含数字、字符串、元组等不可变类型的数据,而不能包含列表、字典、集合等可变类型的数据,包含列表等可变类型数据的元组也不能作为集合的元素。集合不支持使用下标直接访问特定位置上的元素,也不支持使用random中的choice()函数从集合中随机选取元素,但支持使用random模块中的sample()函数随机选取部分元素。】
    字符串str:‘abcd’ “abcd” ‘’‘a"bc"d’’’
    【使用单引号、双引号、三引号作为定界符,不同定界符之间可以互相嵌套;前面加字母r或R表示原始字符串,任何字符都不进行转义】
    2.功能和用法
    (1)可用下标0寻找列表或元组的第一个元素;而字典不可下标,应用“键”寻找对应的值。
    (2)列表,字典,集合可变;元组,字符串不可变。所以不可以修改字符串里的内容,也不能删除其中的字符。所以元组不存在追加插入删除等函数,且元组可使代码更安全。
    (3)元组可以作为字典的键,也可作为集合的元素;列表均不可。
    (4)字符串,列表和元组的元素是有顺序的;集合和字典内的元素则忽略顺序。
    (5)元组可由tuple()转换,列表用list()。
    (6)字符串前加r或者R表示原始字符串,避免因为特殊字符进行转义。
    (7){}:空字典
    []:空列表
    ():空元组
    (8)创建方法除了可以直接创建外:
    列表:x=list()
    元组:x=tuple()
    字典:x=dict()
    集合:x=set()
    字符串:x=str()
    (9)encode()函数可以把字符串转化为字节串,decode()解码成为字符串

    更多相关内容
  • 列表创建一个列表更新列表删除列表元素嵌套列表(类似于多维数组)列表函数,方法3.元组创建元组元组的连接删除元组元组内置函数4.字典访问字典修改字典删除字典的元素字典内置函数,方法5.集合添加元素移除元素集合...

    1.运算符

    算术运算符

    以下假设变量 a=10,变量 b=21
    在这里插入图片描述

    逻辑运算符

    以下假设变量 a 为 10, b为 20:
    在这里插入图片描述

    位运算符

    a = 0011 1100
    b = 0000 1101
    

    在这里插入图片描述

    成员运算符

    在这里插入图片描述

    a = 10
    b = 20
    list = [1, 2, 3, 4, 5 ]
     
    if ( a in list ):
       print ("变量 a 在给定的列表中 list 中")
    else:
       print ("变量 a 不在给定的列表中 list 中")
     
    if ( b not in list ):
       print ("变量 b 不在给定的列表中 list 中")
    else:
       print ("变量 b 在给定的列表中 list 中")
    

    身份运算符

    身份运算符用于比较两个对象的存储单元

    在这里插入图片描述

    注:id(object) 函数返回对象的唯一标识符,标识符是一个整数

    >>>a = 'runoob'
    >>> id(a)
    4531887632   #变量a的唯一标识符
    >>> b = 1
    >>> id(b)
    140588731085608    #变量b的唯一标识符
    

    2.列表

    列表是最常用的 Python 数据类型,它可以作为一个方括号内的逗号分隔值出现。

    列表的数据项不需要具有相同的类型

    创建一个列表

    list1 = ['Google', 'dahe', 1997, 2000]
    list2 = [1, 2, 3, 4, 5 ]
    list3 = ["a", "b", "c", "d"]
    list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']
    

    与字符串的索引一样,列表索引从 0 开始,第二个索引是 1,依此类推

    索引也可以从尾部开始,最后一个元素的索引为 -1,往前一位为 -2,以此类推

    通过索引列表可以进行截取、组合等操作

    截取

    nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
    print(nums[0:4])
    # 从第二位开始(包含)截取到倒数第二位(不包含)
    print (nums[1:-2])
    #从第二位开始,到列表末尾的所有元素
    print(nums[1:])
    --------------------------------------------------
    输出:
    
    [10, 20, 30, 40]
    [20, 30, 40, 50, 60, 70]
    [20, 30, 40, 50, 60, 70, 80, 90]
    

    更新列表

    你可以对列表的数据项进行修改或更新,你也可以使用 append() 方法来添加列表项,如下所示:

    nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
    nums[2]=521     #更改列表中的元素
    nums.append(1314)     #向列表末尾插入数据
    print(nums)
    ---------------------------------------------------------------
    输出:
    [10, 20, 521, 40, 50, 60, 70, 80, 90, 1314]
    

    删除列表元素

    nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
    del nums[1]    #删除第二个元素
    print(nums)
    --------------------------------------------------
    输出:
    [10, 30, 40, 50, 60, 70, 80, 90]
    

    嵌套列表(类似于多维数组)

    >>>a = ['a', 'b', 'c']
    >>> n = [1, 2, 3]
    >>> x = [a, n]
    >>> x
    [['a', 'b', 'c'], [1, 2, 3]]
    >>> x[0]
    ['a', 'b', 'c']
    >>> x[0][1]
    'b'
    

    列表函数,方法

    1.基本使用方法

    nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
    print(len(nums))     #返回列表元素个数
    print(max(nums))     #返回列表的最大值
    print(min(nums))     #返回列表的最小值
    
    print(nums.count(10))   #统计列表中某元素出现的个数
    nums.reverse()       #反向列表元素
    nums.clear()         #清空列表
    print(nums)
    

    2.列表追加

    list.extend() 函数用于在列表末尾一次性追加另一个序列中的多个值

    list1=[10,20,30]
    list2=[521,1314]
    list2.extend(list1)
    #在list2追加元素list1,注意,list1不一定需要是列表类型
    #也可以是元组,集合类型
    print(list2)
    

    3.列表查找list.index(x,[start],[end])

    list1=['Google','Tencent','ctfoj']
    print(list1.index('Google'))      #输出:0
    print(list1.index('aiqiyi'))      #没有找到,返回一个异常信息
    

    4.列表排序

    list.sort([key],[reverse]) 函数用于对原列表进行排序

    参数:

    • key – 主要是用来进行比较的函数
    • reverse – 排序规则,reverse = True 降序, reverse = False 升序(默认)

    演示:

    
    # 获取列表的第二个元素
    def takeSecond(elem):
        return elem[1]
    
    
    # 列表
    random = [(2, 2), (3, 4), (4, 1), (1, 3)]
    
    # 指定第二个元素排序,降序排序
    random.sort(key=takeSecond,reverse=True)
    
    print('排序列表:', random)
    

    5.插入元素到列表中

    list.insert(index,obj)
    

    参数:

    • index – 对象obj需要插入的索引位置
    • obj – 要插入列表中的对象
    list1 = ['Google', 'imustoj', 'Taobao']
    list1.insert(1, 'Baidu')
    print ('列表插入元素后为 : ', list1)
    ----------------------------------------------------
    输出:
    
    列表插入元素后为 :  ['Google', 'Baidu', 'imustoj', 'Taobao']
    

    6.移除列表元素

    list1 = ['Google', 'imustctf', 'Taobao', 'Baidu']
    list1.remove('Taobao')
    print ("列表现在为 : ", list1)
    list1.remove('Baidu')
    print ("列表现在为 : ", list1)
    -------------------------------------------------------
    输出:
    列表现在为 :  ['Google', 'imustctf', 'Baidu']
    列表现在为 :  ['Google', 'imustctf']
    

    7.移除列表中的某一个元素

    list.pop([index]) index默认为-1,会返回删除的元素

    list1 = ['Google', 'imustctf', 'Taobao']
    list1.pop()
    print ("列表现在为 : ", list1)
    list1.pop(1)
    print ("列表现在为 : ", list1)
    ---------------------------------------------------
    输出:
    
    列表现在为 :  ['Google', 'imustctf']
    列表现在为 :  ['Google']
    

    3.元组

    Python 的元组与列表类似,不同之处在于元组的元素不能修改

    元组使用小括号 ( ),列表使用方括号 [ ]。

    元组与字符串类似,下标索引从 0/-1 开始,可以进行截取,组合等,元组可以使用下标索引来访问元组中的值

    创建元组

    tup=(1,2,3)
    print(tup)
    #注意,当元组中只有一个元素时,要用如此表示
    #tup=(1,),否则编译器会把它当作整形来对待
    

    元组的连接

    元组中的元素值是不允许修改的,但我们可以对元组进行连接组合

    tup1 = (12, 34.56)
    tup2 = ('abc', 'xyz')
    # 以下修改元组元素操作是非法的。
    # tup1[0] = 100
    # 创建一个新的元组
    
    tup3 = tup1 + tup2
    print(tup3)
    ------------------------------------
    输出:
    (12, 34.56, 'abc', 'xyz')
    

    删除元组

    元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组

    tup = ('Google', 'imustctf', 1997, 2000)
    del tup     #删除一整个元组
    print("删除后的元组 tup : ")
    print(tup)
    --------------------------------------------------
    输出:异常信息
    

    元组内置函数

    在这里插入图片描述


    4.字典

    字典是另一种可变容器模型,且可存储任意类型对象。

    字典的每个键值对用冒号 : 分割,每个对之间用逗号(,)分割,整个字典包括在花括号 {} 中 ,格式如下所示:

    注:键必须是唯一的,但值则不必。值可以取任何数据类型,但键必须是不可变的,如字符串,数字

    d = {key1 : value1, key2 : value2, key3 : value3 }
    tinydict = {'name': 'imustctf', 'likes': 123, 'url': 'imustctf.top'}
    

    在这里插入图片描述

    访问字典

    把相应的键放入到方括号中

    tinydict = {'name': 'imustctf', 'likes': 123, 'url': 'imustctf.top'}
    print(tinydict['name'])
    print(tinydict['now'])     #字典中没有的数据,访问会抛出一个异常
    

    修改字典

    tinydict = {'Name': 'imustctf', 'Age': 7, 'Class': 'First'}
    
    tinydict['Age'] = 8  # 更新 Age
    tinydict['School'] = "内蒙古科技大学"  # 添加信息
    

    删除字典的元素

    tinydict = {'Name': 'imustctf', 'Age': 7, 'Class': 'First'}
    
    del tinydict['Name']  # 删除键 'Name'
    #tinydict.pop['name']  删除键的函数表示方法
    #tinydict.popitem()    删除字典的最后一串元素
    tinydict.clear()  # 清空字典
    del tinydict  # 删除字典
    

    字典内置函数,方法

    1.dict.fromkeys(seq,[value])

    用于创建一个新字典,以序列 seq 中元素做字典的键,value 为字典所有键对应的初始值

    参数:

    • seq – 字典键值列表。
    • value – 可选参数, 设置键序列(seq)对应的值,默认为 None。
    seq = ('name', 'age', 'sex')
    
    tinydict = dict.fromkeys(seq)
    print(tinydict)
    
    tinydict = dict.fromkeys(seq, 10)
    print(tinydict)
    ----------------------------------------------
    输出:
    {'name': None, 'age': None, 'sex': None}
    {'name': 10, 'age': 10, 'sex': 10}
    

    2.len(dict) 返回字典的个数

    tinydict = {'Name': 'imustctf', 'Age': 7, 'Class': 'First'}
    print(len(tinydict))      #输出字典的个数
    

    3.dict.items()

    以列表返回视图对象,是一个可遍历的key/value 对

    dict1={'one':1,'two':2}
    print(dict1.items())
    --------------------------------
    输出:
    dict_items([('one', 1), ('two', 2)])
    

    将字典的 key 和 value 组成一个新的列表:

    d={1:"a",2:"b",3:"c"}
    result=[]
    for k,v in d.items():
        result.append(k)
        result.append(v)
    
    print(result)
    ---------------------------------------------
    输出:
    [1, 'a', 2, 'b', 3, 'c']
    

    4.update添加

    d={1:"a",2:"b",3:"c"}
    c={4:"d"}
    d.update(c)     #将c字典添加到d字典里
    print(d)
    --------------------------
    输出:
    {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
    

    5.集合

    集合(set)是一个无序的不重复元素序列,支持集合的运算操作

    >>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}     #创建一个集合
    >>> print(basket)                      
    # 这里演示的是去重功能{'orange', 'banana', 'pear', 'apple'}
    
    
    >>> # 下面展示两个集合间的运算
    >>> a = set('abracadabra')    #set方法创建集合
    >>> b = set('alacazam')
    >>> a - b                              
    # 集合a中包含而集合b中不包含的元素
    {'r', 'd', 'b'}
    >>> a | b                              
    # 集合a或b中包含的所有元素
    {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
    >>> a & b                              
    # 集合a和b中都包含了的元素
    {'a', 'c'}
    >>> a ^ b                              
    # 不同时包含于a和b的元素{'r', 'd', 'b', 'm', 'z', 'l'}
    

    添加元素

    1.s.add(x)

    将元素 x 添加到集合 s 中(开头处),如果元素已存在,则不进行任何操作

    thisset = set(("Google", "imustctf", "Taobao"))
    thisset.add("jingdong")
    print(thisset)
    ---------------------------------------------------
    输出:
    {'jingdong', 'Google', 'imustctf', 'Taobao'}
    

    2.s.update(x)

    添加元素,且参数可以是列表,元组,字典等

    thisset = set(("Google", "imustctf", "Taobao"))
    thisset.update({1,3})
    print(thisset)
    thisset.update([1,4],[5,6])
    print(thisset)
    ----------------------------------------------------
    输出:
    {'Google', 'Taobao', 1, 3, 'imustctf'}
    {'Google', 'Taobao', 1, 3, 4, 5, 6, 'imustctf'}
    

    移除元素

    1.s.remove(x)

    将元素 x 从集合 s 中移除,如果元素不存在,则会发生错误

    thisset = {"Google", "imustctf", "Taobao"}
    thisset.remove("Google")
    

    2.s.discard(x)

    移除集合中的元素,且如果元素不存在,不会发生错误

    thisset = {"Google", "imustctf", "Taobao"}
    thisset.discard("imustctf")
    

    3.s.pop()

    随机删除集合中的一个元素

    thisset = {"Google", "imustctf", "Taobao"}
    thisset.pop()
    

    多次执行测试结果都不一样。 set 集合的 pop 方法会对集合进行无序的排列,然后将这个无序排列集合的左面第一个元素进行删除

    4.s.clear()

    清空集合中的元素

    thisset = {"Google", "imustctf", "Taobao"}
    thisset.clear()
    

    集合内置方法

    1.差集

    x = {"apple", "banana", "cherry"}
    y = {"google", "microsoft", "apple"}
    
    z = x.difference(y)
    #返回x与y的差集,元素包含在集合 x ,但不在集合 y
    print(z)
    
    x.difference_update(y)
    #移除x集合中两个集合中都存在的元素
    print(x)
    --------------------------------------------------
    输出:
    {'cherry', 'banana'}
    {'cherry', 'banana'}
    

    2.交集

    x = {"apple", "banana", "cherry"}
    y = {"google", "runoob", "apple"}
    
    z = x.intersection(y)
    #返回集合的交集
    print(z)
    
    x.intersection_update(y)
    #返回x与y都存在的元素,并赋值给x集合
    print(x)
    -----------------------------------------------
    输出:
    {'apple'}
    {'apple'}
    

    3.并集

    x = {"a", "b", "c"}
    y = {"f", "d", "a"}
    z = {"c", "d", "e"}
    
    result = x.union(y, z)
    #合并多个集合
    
    print(result)
    -----------------------------------
    输出:
    {'e', 'b', 'd', 'c', 'f', 'a'}
    

    4.集合的一些判断

    x = {"apple", "banana", "cherry"}
    y = {"google", "runoob", "facebook"}
    
    z = x.isdisjoint(y)
    #判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False
    print(z)
    
    z2 = x.issubset(y)
    #判断x是否为y集合的子集,是则返回True,不是则返回False
    print(z2)
    ----------------------------------------------------------------------
    输出:
    True
    False
    

    版权声明:本文教程基于菜鸟教程

    展开全文
  • Python语法——列表元组集合字典 综述: 列表(List) [ ] 是一种有序和可更改 的集合。允许重复的成员。 元组(Tuple) ( ) 是一种有序且不可更改的集合。允许重复的成员。 集合(Set) { } 是一个无序和无...

    Python语法——列表、元组、集合、字典

    综述:

    列表(List)    [         ]
    是一种有序和可更改 的集合。允许重复的成员。
    元组(Tuple) (        )
    是一种有序且不可更改的集合。允许重复的成员。
    集合(Set)     {        }
    是一个无序和无索引的集合。没有重复的成员。
    词典(Dictionary){"key":"value"......}
    是一个无序,有索引和可变的集合。没有重复的成员。
    

    一、列表的相关操作

    #创建列表
    thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
    print(thislist)
    
    #访问
    负索引表示从末尾开始,0 表示第一个项目,-1 表示倒数第一个项目,依此类推。
    print(thislist[-1])  #结果是 mango
    
    #len()方法   获取列表有多少项  print(len(thislist))
    #count()方法 返回具有指定值的元素数量 变量=列表.count("元素")
    #reverse()方法 反转元素的排序顺序 列表.reverse()
    #sort()方法  默认情况下,对列表进行升序排序,还可以让函数来决定排序标准
    list.sort(reverse=True/False, key=函数方法)
    实例:
            def myFunc(e):
              return len(e)
            cars = ['Porsche', 'Audi', 'BMW', 'Volvo']
            cars.sort(key=myFunc)
            print(cars)
    count()函数:统计了列表指定元素的个数
    实例:
            >>> a = 'banana pie banana'
            >>> a.count('a',2)
            5
    #列表的增
    1. append()方法 将项目添加到列表的末尾 方法:列表.append("元素")
    2. insert()方法 在指定的索引出添加项目 方法:列表.insert(索引位置,"元素")
    3. extend()方法 指定的列表元素(或任何可迭代的元素)添加到当前列表的末尾 方法:目标列表.extende(后接的列表)
    #列表的删
    1. remove()方法 删除指定的元素 方法:列表.remove("元素") 删除列表第一个匹配项
    2. pop()方法    删除指定的索引(如果未指定索引,则删除最后一项)方法:列表.pop(index)
    3. del()方法    删除指定的索引 方法:del thinlist[index]
                    删除完整的列表 方法:del 列表名
    4. clear()方法  清空列表内容,保留列表格式 方法:列表名.clear()
    #列表的改
     直接覆盖
    #列表的查
    if "apple" in thislist:
      print("Yes, 'apple' is in the fruits list")
    

    二、元组的相关操作

    #创建元组
    thistuple = ("apple", "banana", "cherry")
    print(thistuple)
    
    #访问
    返回第三、第四、第五个项目
    thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
    print(thistuple[2:5])  左闭右开
    print(thistuple[-4:-1]) 左开右闭
    #元组的增
    #元组的删
    #元组的改
        注意:
            创建元组后,您将无法更改其值。元组是不可变的,或者也称为恒定的。
            但是有一种解决方法。您可以将元组转换为列表,更改列表,然后将列表转换回元组。
        实例:
            x = ("apple", "banana", "cherry")
            y = list(x)
            y[1] = "kiwi"
            x = tuple(y)
            print(x)
    #合并两个元组
    实例:
        tuple1 = ("a", "b" , "c")
        tuple2 = (1, 2, 3)
        tuple3 = tuple1 + tuple2
        print(tuple3)
    

    三、集合的相关操作

    #创建集合
    thisset = {"apple", "banana", "cherry"}
    print(thisset)
    #访问
        无法通过引用索引来访问 set 中的项目,因为 set 是无序的,项目没有索引。
        但是您可以使用 for 循环遍历 set 项目,或者使用 in 关键字查询集合中是否存在指定值。
    #集合的增
    1. add() 要将一个项添加到集合 方法:集合.add("元素")
    2. update() 要向集合中添加多个项目 方法:集合.update(["orange", "mango", "grapes"])
    实例:
        set1 = {"a", "b" , "c"}
        set2 = {1, 2, 3}
        set1.update(set2)
        print(set1)
    3. union() 返回一个新集合,其中包含两个集合中的所有项目 
    实例:
        set1 = {"a", "b" , "c"}
        set2 = {1, 2, 3}
        set3 = set1.union(set2)
        print(set3)
    '''注意:union() 和 update() 都将排除任何重复项。'''
    
    #集合的删
    1. remove() 与列表一致            如果要删除的项目不存在 将引发错误
    2. discard() 集合.discard("元素") 如果要删除的项目不存在 不会引发错误
    3. pop() 与列表一致 但是注意:     集合是没有索引的,因此在使用该方法时,您不会知道删除的是哪个项目
    4. del() 与列表一致
    #集合的改
    #集合的查
     1.for 循环遍历
     2.if xx in xx:
    

    四、字典的相关操作

    #字典的创建
    thisdict =	{
      "brand": "Porsche",
      "model": "911",
      "year": 1963
    }
    print(thisdict)
    #访问
        通过在方括号内引用其键名来访问字典的项目
        x = thisdict["model"]
        #打印所有键名
        for x in thisdict:
        	print(x)
        #打印所有值
        for x in thisdict:
      		print(thisdict[x])
        #打印键和值
        for x, y in thisdict.items():
      		print(x, y)
    #字典的改
        直接覆盖
        thisdict["year"] = 2019
    #字典的删
    1. pop() 删除键和值 字典.pop("key")
    2. popitem() 删除最后的键和值 字典.popitem()
    3. del 关键字删除具有指定键名的项目 也可以完全删除字典
    4. clear() 关键字清空字典
    
    展开全文
  • 列表中的数据类型可以包含多种,包含数字、字符串、字典、布尔型等,并且列表中还可以嵌套列表 print(type([1, 2, 3, 4, 5, 6])) print(type(['Hello', 'World', 1, 6])) print(type(['Hello', 1, 2, True, 'a'])) ...

    1、列表(list)
    列表中的数据类型可以包含多种,包含数字、字符串、字典、布尔型等,并且列表中还可以嵌套列表

    print(type([1, 2, 3, 4, 5, 6]))
    print(type(['Hello', 'World', 1, 6]))
    print(type(['Hello', 1, 2, True, 'a']))
    print(type([['Hello', 1, 2, 3], [True, 1]]))
    # 列表中嵌套列表
    print(type([['Hello', 'World'], [1, 2, 3], [True, False]]))
    print(type([['Hello', 'World'], [1, 2, 3], [True, False], {'name': 'alex', 'age': 18}]))
    

    结果为:
    <class ‘list’>
    <class ‘list’>
    <class ‘list’>
    <class ‘list’>
    <class ‘list’>
    <class ‘list’>

    • 列表的访问
    print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][0])
    print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][3])
    print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][0:2])
    print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][-1:])
    print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][-1])
    

    结果为:

    新月打击
    月神冲刺
    [‘新月打击’, ‘苍白之瀑’]
    [‘月神冲刺’]
    月神冲刺

    可以发现,单一数字的索引来访问的时候,得到的是一个元素;用冒号的方式来访问,得到的是一个列表,哪怕这个列表只有一个元素

    • 列表的操作
    print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"] + ["点燃", "打击"])
    print(["点燃", "打击"]*3)
    

    结果为:

    [‘新月打击’, ‘苍白之瀑’, ‘月之降临’, ‘月神冲刺’, ‘点燃’, ‘打击’]
    [‘点燃’, ‘打击’, ‘点燃’, ‘打击’, ‘点燃’, ‘打击’]

    注意: print([“点燃”, “打击”]-[“点燃”]) # 输出错误


    2、元组(tuple)

    元组中的数据类型也可以包含多种

    print((1, 2, 3, 4, 5))
    print((1, '-1', True, 'morning', {'name': 'alex', 'age': 18}, [1, 'Hello', '1']))
    

    结果为:

    (1, 2, 3, 4, 5)
    (1, ‘-1’, True, ‘morning’, {‘name’: ‘alex’, ‘age’: 18}, [1, ‘Hello’, ‘1’])

    • 元组的访问
    print((1, 2, 3, 4, 5)[0])
    print((1, 2, 'morning', 4, True)[0:3])
    print((1, 2, 'morning', 4, True)[-1:])
    print((1, 2, 'morning', 4, True)[-1])
    print((1, 2, 3) + (4, 5, 6))
    print((1, 2, 3) * 3)
    print((1, 2)[-1:])
    

    结果为:

    1
    (1, 2, 'morning')
    (True,)
    True
    (1, 2, 3, 4, 5, 6)
    (1, 2, 3, 1, 2, 3, 1, 2, 3)
    (2,)
    

    注意:单一数字的索引来访问的时候,得到的是一个元素;用冒号的方式来访问,得到的是一个元组,哪怕这个元组只有一个元素

    • 类型的判断1
    print(type((1, 2, 3)))
    print(type(1))
    print(type((1)))  # 小括号代表运算符号时,比如(1+1)*2,和元组的括号有冲突,Python当括号里面只有一个元素时,规定为运算符号
    # 定义只有一个元素的元组
    print(type((1,)))
    # 表示一个空的元组
    print(type(()))
    

    结果为:

    <class 'tuple'>
    <class 'int'>
    <class 'int'>
    <class 'tuple'>
    <class 'tuple'>
    
    • 类型的判断2
    print(type("Hello"))
    print(type(("Hello")))
    print(type([1, 2, 3]))
    print(type([1]))
    

    结果为:

    <class 'str'>
    <class 'str'>
    <class 'list'>
    <class 'list'>
    

    3、str list tuple ---->序列

    • 每个元素都被分配一个序号
    print((1, 2, 3)[2])
    print('hello world'[2])
    

    结果为:

    3
    l
    
    • 都可以进行切片操作
    print([1, 2, 3, 4, 5][0:3])
    print([1, 2, 3, 4, 5][-1:])
    print("Hello world"[0:8:2])
    

    结果为:

    [1, 2, 3]
    [5]
    Hlow
    
    • 都可进行 + 和 *
    • 判断元素是否在序列中
    print(3 in [1, 2, 3, 4, 5])
    print(3 not in [1, 2, 3, 4, 5])
    

    结果为:

    True
    False

    • 都可以求取序列的长度、元素的最大最小值
    print(len([1, 2, 3, 4, 5, 6]))
    print(len("Hello world"))
    
    print(max([1, 2, 3, 4, 5, 6]))
    print(min([1, 2, 3, 4, 5, 6]))
    
    print(max("Hello world"))
    print(min("Helloworld"))
    

    结果为:

    6
    11
    6
    1
    w
    H
    

    求取ASCII 的求取

    print(ord('H'))
    print(ord('w'))
    print(ord(' '))
    

    结果为:

    72
    119
    32


    4、 集合

    • 无序
    print(type({1, 2, 3, 4, 5, 6}))
    # print({1, 2, 3, 4, 5, 6}[0])  # 错误
    

    结果为:

    <class 'set'>
    
    • 不重复
    print({1, 1, 2, 3, 6, 6})
    

    结果为:

    {1, 2, 3, 6}
    
    • 长度
    print(len({1, 2, 3}))
    

    结果为:

    3
    
    • 剔除3,4,求集合的差集
    print({1, 2, 3, 4, 5, 6}-{3, 4})
    

    {1, 2, 5, 6}

    • 求集合的交集
    print({1, 2, 3, 4, 5, 6} & {3, 4})
    

    结果为:

    {3, 4}
    
    • 两个合并成一个,不出现相同的元素,合集或并集
    print({1, 2, 3, 4, 5, 6} | {3, 4, 7})
    

    结果为:

    {1, 2, 3, 4, 5, 6, 7}
    
    • 定义一个空的集合
    print(type({}))
    print(type(set()))
    

    结果为:

    <class 'dict'>
    <class 'set'>}
    

    约个拓展练习可好:

    快乐的LeetCode — 14. 最长公共前缀 方法2中包含了集合的巧妙使用


    5、字典(dict)
    形式:{key1:value1,key2:value2,key3:value3,} 。 可以有很多个key和value,属于集合类型(set),不是序列类型

    • 访问
    print({'Q': "新月打击", 'W': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"}['Q'])
    
    # 相同的key情况,尽管有结果输出
    print({'Q': "新月打击", 'Q': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"}['Q'])
    
    # 验证发现,已经存在丢失
    print({'Q': "新月打击", 'Q': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"})
    
    

    结果为:

    新月打击
    苍白之瀑
    {'Q': '苍白之瀑', 'R': '月之降临', 'E': '月神冲刺'}
    
    • 可以有数字类型的key
    print({1: "新月打击", '1': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"})
    
    # key必须是不可变的类型, 数字1,字符串"1"
    # 反例 print({[1, 2]: "新月打击", 'Q': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"})
    

    结果为:

    {1: '新月打击', '1': '苍白之瀑', 'R': '月之降临', 'E': '月神冲刺'}
    
    • value 本身可以是 int float str set dict list…
    print({1: "新月打击", '1': "苍白之瀑", 'R': {1, 2, 3}, 'E': "月神冲刺"})
    

    结果为:

    {1: '新月打击', '1': '苍白之瀑', 'R': {1, 2, 3}, 'E': '月神冲刺'}
    
    • 定义空的字典
    print(type({}))
    

    结果为:

    <class 'dict'>
    

    大家加油!
    第4章 Python中表示“组”的概念与定义.mp4

    展开全文
  • 【python学习】列表元组字典集合(详解)

    千次阅读 多人点赞 2022-03-31 16:34:55
    关注作者,持续阅读作者的文章,学习更多知识! ... 一、列表 列表(list)是Python中的一种数据结构,它可以存储不同类型的数据。...3.每个元素的排列是有序号的,元素相同但排列不同的列表属于不同的列表。 4...
  • 列表是处理一组有序的数据结构,可以读写,添加和删除,或者搜索列表里的元素。因为可以添加和删除,所以称为可变的数据类型,即这种类型是可以被改变的,并且列表可以嵌套。 res = [1,2,'yihang'] #增加元素:...
  • 本篇主要介绍Python里的数据结构,包括列表元组字典集合、字符串的使用,学习这些序列的方法以及性质。
  • 列表: index():返回指定数据所在位置的下标 ,查不到会报错 index(数据, 开始位置下标, 结束位置下标) count():统计指定数据在当前列表中出现的次数。 len():访问列表⻓度,即列表中数据的个数。 in:判断指定...
  • 1.1 列表(list): 1.2 元组(tuple): 1.3 字典(dict ): 1.4 集合(set): 2.创建 2.1 创建列表 2.2 创建元组 2.2 创建字典 2.4 创建集合 3.查找 3.1 查找列表元素 3.2 查找元组元素 3.3 查找...
  • Python:列表元组字典集合

    千次阅读 2019-03-26 17:38:39
    1,列表元组字典集合 1.1,概念 列表(list):是长度可变有序的数据存储器,可通过下标索引取到相应的数据。 元组(tuple):固定长度不可变的顺序容器,访问效率高,适合存储一些长常量数据,可以作为...
  • 1.列表元组字典是有顺序的,而集合是没顺序的 2.列表是以方括号形式表示,元组是以圆括号表示,字典以花括号表示,集合则是以[()]的形式表示 3.列表是可变对象,它支持在原处修改的操作.也可以通过指定的索引和分...
  • 二、元组列表的区别 (1)元组号称不可修改的列表,也就是只能查 果然是好兄弟,他俩还可以互换 元组 = tuple(列表列表 = list(元组) 三、集合列表的区别 (1)集合无序、列表有序 (2)集合成员不可...
  • python3-列表元组字典集合概述一、列表1.定义2.函数:排序反转3.基本操作:增、删、改、查4.列表推导式5. 练习二、元组1.基本操作三、字典1. 增删改查基本操作四、集合1. 基本操作2. ord 和chr五、公共方法1. ...
  • 一文看懂系列:元组列表字典集合究竟怎么学 一、数据结构 1、元组 含义:元组是一种固定长度、不可变的Python对象序列。虽然对象元组中存储的对象其自身是可变的,但是元组一旦创建,各个位置上的对象是...
  • 列表元组字典集合的异同 1.list: (1)可以用list()函数或者方括号[]创建,元素之间用逗号’,‘’分隔; (2)列表的元素不需要具有相同的类型,可以是多种类型; (3)使用索引来访问元素; (4)可...
  • 列表元组字典集合,都用于存放数据,它们区别总结如下: 项目 列表 元组 字典 集合 关键字 list tuple dict set 是否可变 可变 不可变 可变 可变 是否有序 有序 ...
  • 列表list定义符号:[]创建:[]直接创建 , list()可变性:可变是否有序:有序元素是否重复:可以重复切片:支持切片索引:支持索引访问:索引访问删除:del()list.remove(value)list.pop()修改插入:list[]=append()...
  • 只有元组属于不可变类型,因此它没有增删查改操作,其余列表字典集合都属于可变对象。集合字典不支持索引、切片、相加和相乘操作。1. 序列共同特点在 Python 中,序列类型包括字符串、列表元组集合字典...
  • 参考文档https://blog.csdn.net/Yeoman92/article/details/56289287理解Python中列表元组字典集合的区别列表元组字典集合的区别是python面试中最常见的一个问题。这个问题虽然很基础,但确实能反映出...
  • 1、列表(list) 操作:索引,切片,增,乘,查找(注:列表的数据项不需要具有相同的类型,类似tuple,但列表允许修改值,tuple不允许) 翻转(List.reverse())、排序(List.sort())、列表嵌套(List=[list1, ...
  • python列表元组字典集合总结

    千次阅读 2020-01-31 20:02:16
    列表元组字典分别对应list, tuple, dict 1.list的简介 列表是python内置的一种数据类型,是一种有序的集合,可对其进行增删改查。列表中的元素不一定是同类型的。列表是可变序列 2.list的初始化 list = [] #...
  • 列表转换为元组。 >>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu'] >>> tuple1=tuple(list1) >>> tuple1 ('Google', 'Taobao', 'Runoob', 'Baidu') 字典 1 radiansdict....
  • 列表元组字典集合的区别是python面试中最常见的一个问题。这个问题虽然很基础,但确实能反映出面试者的基础水平。1.列表(List)什么是列表呢?我觉得列表就是我们日常生活中经常见到的清单。比如,统计过去一周...
  • Python有6个序列的内置类型,但最常见的是列表元组。序列都可以进行的操作包括索引,切片,加,乘,检查成员。此外,Python已经内置确定序列的长度以及确定最大和最小的元素的方法。列表是最常用的Python数据类型...
  • python数据类型前言一、字符串二、列表三、元组四、字典五、集合 前言 Python3 中有六个标准的数据类型: Number(数字) String(字符串) List(列表) Tuple(元组) Set(集合) Dictionary(字典) Python3 的...
  • 1、列表 列表:使用方括号将用逗号分隔不同的数据项括起来。 可以存储不同类型的数据。 list = [1,‘a’,[1,2 ],“python”] 创建列表 list = [obj0,obj1] list1 = [1,2,3] list2 = ["C","python","java"] list3 = ...
  • 字符串 字符串就是一系列数字,在...python的字串列表有2种取值顺序: 从左到右索引默认0开始的,最大范围是字符串长度少1 从右到左索引默认-1开始的,最大范围是字符串开头 如果你要实现从字符串中获取一段子字...
  • python中列表字典元组集合的特点以及差异

    千次阅读 多人点赞 2020-05-15 23:53:12
    1.列表(List) 列表的特点 1. 数据按顺序存储 2. 列表有正序、倒序两种索引 3. 列表可存储任意类型的数据,并且允许重复。 列表的遍历: lst = [1,2,3] for i in range(len(lst)): print(lst[i]) 列表的增删改...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,266
精华内容 7,706
关键字:

列表元组字典集合的符号