数据类型内置方法:列表/元组/集合

list列表类型内置方法

  1. 作用:多个装备、多个爱好、多门课程,甚至是多个女朋友
  2. 定义方式:[]内用逗号隔开,可以有多个任意数据类型的元素
friends_list = ['longzeluola','canglaoshi','qiaobenai','nick']
lis = list('abcd')
  1. 方法:

    1. 优先掌握

      1. 索引取值(正向取值+反向取值) 即可取又可存

        #list之索引取值
        name_list={'nick','jason','tank','sean'}
        name_list[0]='nick handsome'
        #name_list[1000]='tank handsome'    #报错
        
        print(f"name_list[0]:{name_list[0]}")

        name_list[0]:{name_list[0]}

      2. 切片
        #list之切片
        name_list=['nick','jason','tank','jick']
        
        print(name_list[0:3:2])                  ----->'nick','tank'
      3. 长度len
        #list之长度
        name_list=['nick','jason','tank','jick']
        
        print(len(name_list))                    ------>4
      4. append追加值
        # list之追加值
        name_list = ['nick', 'jason', 'tank', 'sean']
        name_list.append('tank handsome' )
        
        print(name_list)
                   ------->['nick', 'jason', 'tank', 'jick', 'tank handsome']
      5. 成员运算in和not in
        # list之成员运算in和not in
        name_list = ['nick', 'jason', 'tank', 'sean']
        
        print('tank handsome' in name_list )      ----->Fslse
        print('nick handsome' not in name_list)      ------>true
      6. for循环
        # list之循环
        name_list = ['nick', 'jason', 'tank', 'sean']
        
        for name in name_list:
            print(name)
        nick
        jason
        tank
        jick
      7. 删除del
        # list之删除
        name_list = ['nick', 'jason', 'tank', 'sean']
        del name_list[2]
        
        print(name_list)                ---->['nick', 'jason', 'jick']
    2. 需要掌握
      1. count计数

        # list之count()
        name_list = ['nick', 'jason', 'tank', 'sean']
        
        print(name_list.count('tank'))        ------>1
      2. remove 如果删除对象不存在则报错,按照指定的元素删除
        # list之remove()
        name_list = ['nick', 'jason', 'tank', 'sean']
        
        print(name_list.remove('tank'))     ------>        None
        print(name_list)          ----->['nick', 'jason', 'sean']
      3. reverse 反转列表
        # list之reverse()
        name_list = ['nick', 'jason', 'tank', 'sean']
        name_list.reverse()
        
        print(name_list)         ------>['sean', 'tank', 'jason', 'nick']
      4. pop 默认删除最后一个值,删除指定索引的值
        # list之pop(),pop()默认删除最后一个元素
        name_list = ['nick', 'jason', 'tank', 'sean']
        
        print(name_list.pop(1))           ----->jason
        
        print(name_list)            ----->['nick', 'tank', 'sean']
      5. insert 在索引前面加入一个值
        # list之insert()
        name_list = ['nick', 'jason', 'tank', 'sean']
        name_list.insert(1,'handsome')
        
        print(name_list)    --->['nick', 'handsome', 'jason', 'tank', 'sean']
      6. sort 排序列表
        # list之sort(),使用sort列表的元素必须是同类型的
        name_list = ['nick', 'jason', 'tank', 'sean']
        name_list.sort()
        
        print(name_list)        --->['jason', 'nick', 'sean', 'tank']
        name_list.sort(reverse=True)
        print(name_list)      ------->['tank', 'sean', 'nick', 'jason']
      7. index 获取指定元素的索引,但是只会获取第一次
        # list之index()
        name_list = ['nick', 'jason', 'tank', 'sean']
        
        print(name_list.index('nick'))           ---->0
      8. copy 复制
        # list之copy()
        name_list = ['nick', 'jason', 'tank', 'sean']
        
        print(name_list.copy())      --->['nick', 'jason', 'tank', 'sean']
      9. extend 扩展,把extend里的列表的元素添加到原列表中
        # list之extend()
        name_list = ['nick', 'jason', 'tank', 'sean']
        name_list2=['nick handsome' ]
        name_list.extend(name_list2)
        
        print(name_list)
                       -->['nick', 'jason', 'tank', 'sean', 'nick handsome']
      10. clear 清除列表/清空列表
        # list之clear()
        name_list = ['nick', 'jason', 'tank', 'sean']
        name_list.clear()
        
        print(name_list)      ------->[]
  2. 多个值or一个值 :多个值
  3. 有序or无序:有序
    hobby_list = ['read', 'run', 'girl']
    print(f'first:{id(hobby_list)}')           --->4522187016
    hobby_list[2] = ''
    print(f'second:{id(hobby_list)}')         ---->4522187016
  4. 可变or不可变:可变数据类型

元组类型内置方法

  1. 作用: 类似于列表,可以存不可以取
  2. 定义方式: 在()内可以有多个任意类型的值,逗号分隔元素
friends_tuple = ('longzeluola','canglaoshi','qiaobenai','nick')
tup = tuple('abcd')
  1. 方法

    1. 索引取值(无法更改)
    2. 切片(顾头不顾尾,步长)
    3. 长度 len
    4. 成员运算 in 和not in
    5. for循环
    6. count
    7. index
  2. 多个值or一个值:多个值
  3. 有序or无序:有序
  4. 可变or不可变:无可变不可变这一说

    列表可变的原因是:索引所对应的值的内存地址是可以改变的

    元组不可变得原因是:索引所对应的值的内存地址是不可以改变的,或者反过来说,只要索引对应值的内存地址没有改变,那么元组是始终没有改变的。

字典类型内置方法

  1. 作用:当列表存在很多值的时候,列表会显得很乱,所以就有了字典。多用于存的值表示的是不同的状态时,例如存的值有姓名、年龄、身高、体重、爱好。
  2. 定义方式:{}内用逗号分隔开多个键值对key:value的值,value可以是任意数据类型,而key通常应该是字符串类型,但是key必须为不可变类型。
nick_info_dict = {
'name':'nick',
'height':180,
'weight':140,
'hobby_list':['read','run','music','fishing','programming','coding','debugging']
}

for k,v in nick_info_dict.items():
    print(k,v)

name nick
height 180
weight 140
hobby_list [‘read‘, ‘run‘, ‘music‘, ‘fishing‘, ‘programming‘, ‘coding‘, ‘debugging‘]

  1. 方法
  2. 按键取值:可存可取
    # dic之按key存取值
    dic = {'a': 1, 'b': 2}
    
    print(f"first dic['a']: {dic['a']}")
    dic['a'] = 3
    
    print(f"second dic['a']: {dic['a']}")

    first dic[‘a‘]: 1
    second dic[‘a‘]: 3

  3. 长度:
    ?```
    print(len(dic))
  4. 键keys() / 值values()/ 键值对items()
    # dic之键keys()、值values()、键值对items(),python2中取出的是列表(鸡蛋);python3中取出的是元组(鸡)
    dic = {'a': 1, 'b': 2}
    
    print(f"dic.keys(): {dic.keys()}")
    print(f"dic.values(): {dic.values()}")
    print(f"dic.items(): {dic.items()}")

    dic.keys(): dict_keys([‘a‘, ‘b‘])
    dic.values(): dict_values([1, 2])
    dic.items(): dict_items([(‘a‘, 1), (‘b‘, 2)])

  5. for循环
    # dic之循环
    # dic是无序的,但是python3采用了底层优化算法,所以看起来是有序的,但是python2中的字典是无序
    dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
    
    for k, v in dic.items():  # items可以换成keys()、values()
        print(k, v)

    a 1
    b 2
    c 3
    d 4

  6. 成员运算in 和 not
    # dic之成员运算in和not in
    dic = {'a': 1, 'b': 2}
    
    print(f"'a' in dic: {'a' in dic}")
    print(f"1 in dic: {1 in dic}")

    ‘a‘ in dic: True
    1 in dic: False

  7. 删除del
    # dic之删除del
    dic = {'a': 1, 'b': 2}
    del dic['a']
    
    print(f"dic.get('a'): {dic.get('a')}")

    dic.get(‘a‘): None

  8. 需要掌握
    1. fromkeys 来自键值,默认把给定列表内的元素取出来当成key,然后使用一个默认value新建一个字典

    # dic之fromkeys()
    dic = dict.fromkeys(['name', 'age', 'sex'], None)
    
    print(f"dic: {dic}")

    dic: {‘name‘: None, ‘age‘: None, ‘sex‘: None}

2. setdefault    如果字典中有该key的话,则key对应的值不变:如果没有,则增加

   ```python
   # dic之setdefault(),有指定key不会改变值;无指定key则改变值
   dic = {'a': 1, 'b': 2}

   print(f"dic.setdefault('a'): {dic.setdefault('a',3)}")
   print(f"dic: {dic}")
   print(f"dic.setdefault('c'): {dic.setdefault('c',3)}")
   print(f"dic: {dic}")
   ```

   dic.setdefault('a'): 1
   dic: {'a': 1, 'b': 2}
   dic.setdefault('c'): 3
   dic: {'a': 1, 'b': 2, 'c': 3}

3. get 如果键不存在,返回不会报错,可以给默认值

   ```python
   # dic之get()
   dic = {'a': 1, 'b': 2}

   print(f"dic.get('a'): {dic.get('a')}")
   print(f"dic.get('c'): {dic.get('c')}")
   ```

   dic.get('a'): 1
   dic.get('c'): None

4. update  有就更新,没有就添加

   ```python
   # dic之update()
   dic1 = {'a': 1, 'b': 2}
   dic2 = {'c': 3}
   dic1.update(dic2)

   print(f"dic1: {dic1}")
   ```

   dic1: {'a': 1, 'b': 2, 'c': 3}
  1. 多个值or一个值:多个值,值可以是多个类型,key必须是不可变类型,通常应该是不可变类型中的字符串类型
  2. 有序or无序:无序
  3. 可变or不可变:可变数据类型

集合类型内置方法

  1. 作用:存多个值,为了集合之间做运算,由于集合内的元素无序且集合元素不可重复,因此集合可以去重,但是去重后的集合会打乱原来元素的顺序。
  2. 定义方式:{}内用逗号分隔开多个元素,每个元素必须是不可变类型。
s = set()

s = {1,2,3,4,5,1}
  1. 方法:

    1. 优先掌握

      1. 去重
      2. 并集 | ,union
        # str之|并集
        pythoners = {'jason', 'nick', 'tank', 'sean'}
        linuxers = {'nick', 'egon', 'kevin'}
        
        print(f"pythoners|linuxers: {pythoners|linuxers}")
        print(f"pythoners.union(linuxers): {pythoners.union(linuxers)}")

        pythoners|linuxers: {‘egon‘, ‘tank‘, ‘kevin‘, ‘jason‘, ‘nick‘, ‘sean‘}
        pythoners.union(linuxers): {‘egon‘, ‘tank‘, ‘kevin‘, ‘jason‘, ‘nick‘, ‘sean‘}

      3. 交集 & intersection
      4. 差集 -difference
      5. 对称差集 ^symmetric_difference
      6. 父集 > >=issuperset
      7. 子集 <&emsp;<=issubset
      8. ==
    2. 需要掌握
      1. add()

        # set之add()
        s = {1, 2, 'a'}
        s.add(3)
        
        print(s)

        {1, 2, 3, ‘a‘}

      2. difference_update
        # str之difference_update()
        pythoners = {'jason', 'nick', 'tank', 'sean'}
        linuxers = {'nick', 'egon', 'kevin'}
        pythoners.difference_update(linuxers)
        
        print(f"pythoners.difference_update(linuxers): {pythoners}")

        pythoners.difference_update(linuxers): {‘tank‘, ‘jason‘, ‘sean‘}

      3. isdisjoint 是否不联合
        # set之isdisjoint(),集合没有共同的部分返回True,否则返回False
        pythoners = {'jason', 'nick', 'tank', 'sean'}
        linuxers = {'nick', 'egon', 'kevin'}
        pythoners.isdisjoint(linuxers)
        
        print(f"pythoners.isdisjoint(linuxers): {pythoners.isdisjoint(linuxers)}")

        pythoners.isdisjoint(linuxers): False

      4. remove # 值不存在会报错
        # set之remove()
        s = {1, 2, 'a'}
        s.remove(1)
        
        print(s)

        {2, ‘a‘}

      5. discard # 放弃,删除,不会报错
        # set之discard()
        s = {1, 2, 'a'}
        # s.remove(3)  # 报错
        s.discard(3)
        
        print(s)

        {1, 2, ‘a‘}

  2. 多个值or一个值:多个值,且值为不可变类型
  3. 有序or无序:无序
  4. 可变or不可变:可变数据类型

数据类型总结

一个值 多个值
整型/浮点型/字符串 列表/元祖/字典/集合/
有序 无序
字符串/列表/元祖 字典/集合
可变 不可变
列表/字典/集合 整型/浮点型/字符串

拷贝

  • ==拷贝/浅拷贝/深拷贝都是针对可变类型数据而言的==
l1 = ['a','b','c',['d','e','f']]
l2 = l1

l1.append('g')

print(l1)  # ['a','b','c',['d','e','f'],'g']
print(l2)  # ['a','b','c',['d','e','f'],'g']

如果l2是l1的拷贝对象,则l1内部的任何数据类型的元素变化,则l2内部的元素也会跟着改变,因为可变类型值变id不变

浅拷贝

import copy

l1 = ['a','b','c',['d','e','f']]
l2 = copy.copy(l1)

l1.append('g')

print(l1)  # ['a','b','c',['d','e','f'],'g']
print(l2)  # ['a','b','c',['d','e','f']]

l1[3].append('g')

print(l1)  # ['a','b','c',['d','e','f','g'],'g']
print(l2)  # ['a','b','c',['d','e','f','g']]

如果l2是l1的浅拷贝对象,则l1内的不可变元素发生了改变,l2不变;如果l1内的可变元素发生了改变,则l2会跟着改变

深拷贝

import copy

l1 = ['a','b','c',['d','e','f']]
l2 = copy.deepcopy(l1)

l1.append('g')

print(l1)  # ['a','b','c',['d','e','f'],'g']
print(l2)  # ['a','b','c',['d','e','f']]

l1[3].append('g')

print(l1)  # ['a','b','c',['d','e','f','g'],'g']
print(l2)  # ['a','b','c',['d','e','f']]

如果l2是l1的深拷贝对象,则l1内的不可变元素发生了改变,l2不变;如果l1内的可变元素发生了改变,l2也不会变,即l2永远不会因为l1的变化而变化

!

```

原文地址:https://www.cnblogs.com/gongjingyun123--/p/10920988.html

时间: 2024-10-01 02:31:40

数据类型内置方法:列表/元组/集合的相关文章

数据类型的内置方法:元组

目录 数据类型的内置方法:元组 作用 定义 优先掌握的内置方法 数据类型的内置方法:元组 作用 能够存储多个元素,元素与元素之间逗号隔开 ,元素可以是任意类型,元组不能被修改. 存一个只or多个值:多个值 有序or无序:有序 可变or不可变:不可变 定义 num = (1,2,3,4,5,6) # num = tuple((1,2,3,4,5,6)) 优先掌握的内置方法 1:按索引取值(正向或反向取),只能取 num = (1,2,3,4,5,6) print(num[5]) # 6 2:切片(

python常用数据类型内置方法介绍

熟练掌握python常用数据类型内置方法是每个初学者必须具备的内功. 一.整型 a = 100 a.xxx() class int(object): def bit_length(self): ##如果将某个整数用2进制表示,返回这个2进制所占bit位数. return 0 def conjugate(self, *args, **kwargs): ##共轭复数 @classmethod # known case def from_bytes(cls, bytes, byteorder, *ar

数据类型内置方法

目录 数据类型内置方法总结 数字类型内置方法 整型int() 浮点型 float() 字符串类型内置方法 列表类型内置方法 元组类型内置方法 字典类型内置方法 集合类型内置方法 数据类型总结 拷贝 深浅拷贝 数据类型内置方法总结 数字类型内置方法 整型int() 定义方式 age = int(28) int()函数可以将数字转换为整型,直接省去小数部分 常用操作 算术操作 + 比较运算符 长整型 python2 中有长整型概念,python3中没有 存一个值 or 多个值 : 一个值 可变 or

数据类型内置方法之数据类型与字符串类型

数据类型内置方法 数字类型内置方法 整型 1.用途:年龄.身份证号码.手机号... 2.定义方式: age1 = 18 age2 = int(18) print(age1) print(id(age1)) print(type(age1)) print(type(age2)) 18 1723559936 <class 'int'> <class 'int'> 3.常用操作和内置方法:+ - * / // ** % :无内置方法 4.存一个值or多个值:一个值 5.有序or无序(有索

数据类型内置方法(1)

数据类型内置方法 为什么要有数据类型 对于不同类型的数据需要不同的数据类型去描述 数字类型内置方法 整形 作用:描述身高.体重.号码等整数 定义:id = 111111 方法:+ - * / % // 存储一个值or多个值:一个值 有序or无序:没有此概念 可变or不可变:不可变 有序无序指数据是否有索引,可变不可变指数据改变后内存地址是否改变 浮点型 作用:描述金额.导弹轨迹等效等小数 定义:salary = 2222.222 方法:+ - * / % // 存储一个值or多个值:一个值 有序

数据类型+内置方法

1什么是数据 2为什么要存数据?数据为什么要分类 3数据类型 1什么是数据 X=10  10就是我们要存的数据 2为什么要存数据?数据为什么要分类 数据是用来表示事物状态的,不用的事物状态需要用不同类型的数据来表示 3数据类型 整型.浮点型.字符串型.列表型.字典型.布尔型 整型int 作用:用来表示年龄.分数.等级.... 定义:age=18   age=int(18) 常规操作:算数运算,比较运算 该类型总结: 只能存一个值 没有有序和无序的说法 是不可变类型数据 浮点型float 作用:用

python之字符串,列表,字典内置方法总结

目录 数字类型的内置方法 整型/浮点型 字符串类型的内置方法 列表的内置方法 字典的内置方法 数字类型的内置方法 整型/浮点型 加 + 减 - 乘 * 除 / 取余 % 余数取整 // 字符串类型的内置方法 掌握 熟悉 了解 按索引取值 ,strs[0] lstrip,rstrip find,rfind 切片,str[::-1] lower,upper index,rindex 长度,len[strs] startswith,endswith count 成员运算,print{" 'llo' i

列表,字典,元组,集合内置方法

列表类型内置方法 作用:多个女朋友/ 定义方式:[]内用逗号隔开多个任意数据类型的元素 friends_list = ['longzeluola','canglaoshi','qiaobenai','nick'] lis = list('abcd') 方法: 优先掌握 索引取值(即可取又可改) 切片 长度 append 成员运算 for循环 需要掌握 count remove reverse pop insert sort index del extend clear 多个值or一个值:多个值

what&#39;s the python之基本运算符及字符串、列表、元祖、集合、字典的内置方法

计算机可以进行的运算有很多种,运算按种类可分为算数运算.比较运算.逻辑运算.赋值运算.成员运算.身份运算.字符串和列表的算数运算只能用+和*,字典没有顺序,所以不能进行算数运算和比较运算.比较运算中==比较的是值,is比较的是id.比较运算只能在同种类型下进行比较.字符串的比较是按照顺序依次进行比较.逻辑运算的顺序先后为要用括号来表示. 基本运算符如下: 算术运算 以下假设a=10,b=20 比较运算 以下假设a=10,b=20 赋值运算 逻辑运算  成员运算 身份运算 what's the 内