zoukankan      html  css  js  c++  java
  • 数据类型操作方法(二)

    1、列表的常用方法

      sort()的用法

    l = [1, 2, 3, 4, 5, 6, 7]
    
    l.sort()  # 排序 默认情况下是从小到大(升序)
    l1 = [43,6,1,7,99]
    l1.sort(reverse=True)  # 可以通过指定参数来修改默认的拍讯规则(降序)
    print(l1)  # [99, 43, 7, 6, 1]

      总结:列表能存多个值,内部元素是有序的,列表是可变数据类型

        PS:队列和堆栈

    # 队列   先进先出
    l1 = []
    # 先进
    l1.append('first')
    l1.append('second')
    l1.append('third')
    # 先出
    print(l1.pop(0))  # first
    print(l1.pop(0))  # second
    print(l1.pop(0))  # third
    
    
    # 堆栈   先进后出
    # 先进
    l1.append('first')
    l1.append('second')
    l1.append('third')
    # 后出
    print(l1.pop())  # third
    print(l1.pop())  # second
    print(l1.pop())  # first

    2、元组及其常用方法

      1、定义:与列表类型比,只不过[]换成()

        可以写成:age=(11,22,33,44,55),本质age=tuple((11,22,33,44,55))

    2、作用:能够存储多个元素,元素与元素之间逗号隔开。元组中的元素可以是任意类型,元组不能被修改

      3、优先掌握的操作

        1、按索引取值(正向取+反向取):只能取 

    t = (1, 2, 3, 'a', 'b', [1, 2, 3])
    
    print(t[0])
    
    t[1] = 'hahah'
    t[-1] = 'hahaha'
    t[-1][0] = '我改了'
    print(t)
    
    del t[0]
    print(t)

         2、切片(顾头不顾尾,具体操作与列表一样)

    t = (1, 2, 3, 'a', 'b', [1, 2, 3])
    
    print(t[::2])

         3、长度len(具体操作与列表一样)

    t = (1, 2, 3, 'a', 'b', [1, 2, 3])
    
    print(len(t))  # 6

        4、成员运算in和not in(具体操作与列表一样)

    t = (1, 2, 3, 'a', 'b', [1, 2, 3])
    
    
    print('a' in t)  # True

        5、循环

    t = (1, 2, 3, 'a', 'b', [1, 2, 3])
    
    
    for i in t:
        print(i)  # 1 2 3 a b [1,2,3]

        6、cuont和index

    具体使用和列表、字符串中的使用一样。count对相同的元素进行计数;index查找元素是若找到元素则返回元素的索引,反之返回报错

    t = (1, 2, 3, 'a', 'b', [1, 2, 3])
    
    print(t.count('a'))  # 1
    print(t.index('xxx'))  # 报错

      4、元组总结:元组能存多个值,内部存储的值是有序的,元组是不可变数据类型

    t2 = (1, 2, 3, 4, [1, 2])
    print(id(t2))  # 1454472798896
    t2[-1].append(666)
    print(t2)  # (1, 2, 3, 4, [1, 2, 666])
    print(id(t2))  # 1454472798896

    3、字典的常用方法

    1、定义:能存存储多组 key:value键值对 key是对value的描述 key通常情况下都是字符串其实这个key只能是不可变类型,value可以是任意数据类型

    d = {'name':'jason','password':123}  # d = dict( {'name':'jason','password':123})
    
    d1 = {1:'1',0:'0',1.11:'1.11',(1,2):'到底能不能呢?'}
    print(d1[1.11])  # 1.11
    print(type(d1))  # dict
    print(d1[(1,2)])  # 到底能不能呢?
    
    d2 = {'name':'jason','name':'tank','name':'nick','password':123}
    
    # print(len(d2))
    # print(d2)
    # 强调:字典的key是不能重复的 要唯一标识一条数据
    # 如果重复了 只会按照最后一组重复的键值对存储

        定义字典的三种方法:

    # 掌握
    # 1
    d1 = {'name':'jason','password':123}
    
    # 2
    # 掌握
    d2 = dict(name='jason',password=123,age=18)  # (******)
    print(d2,type(d2))
    
    
    # 3
    # 了解即可
    l = [
        ['name','jason'],
        ['age',18],
        ['hobby','read']
    ]
    d = {}
    
    for k,v in l:  # ['name','jason'],['age',18]...
    
        d[k] = v
    
    d3 = dict(l)
    print(d3)

      2、优先掌握的操作

        1、按key存取值:可存可取

    d3 = {"name": "jason", "age": 18}
    
    print(id(d3))  # 1968293842448
    print(d3["name"])  # jason
    
    d3["name"] = "alex"
    print(d3["name"])  # alex
    
    d3["pwd"] = "123"  # 赋值语句当key不存在的情况下,会自动新增一个键值对
    print(d3, id(d3))  # {'name': 'alex', 'age': 18, 'pwd': '123'}  1968293842448

        2、长度len:统计的键值对的个数

        3、成员运算in和not in   对于字典来说只能判断key值

    d3 = {'name':'jason','password':'123'}
    
    print('123' in d3)  # False
    print('name' in d3)  # True

        4、删除

        del和pop的使用和李彪中大致相同,不过字典中的pop利用key弹出value,当键不存在是直接报错。

    d3 = {'name':'jason','password':'123'}
    del d3['name']
    print(d3)  # {'password':'123'}
    res1 = d3.pop('name')  # 弹出仅仅是value
    res2 = d3.pop('age')  # 当键不存在的时候直接报错
    print(res1)  # jason
    print(res2)  # 报错
    print(d3)  # {'password':'123'}
    d3.clear()  # 清空
    print(d3)  # {}

        5、获取所有的键keys(),获取所有的值values(),获取所有的键值对items()

    d1 = {'name':'jason','password':123}
    print(d1.keys())  # dict_keys(['name', 'password'])  老母猪
      for k in d1.keys():
         print(k)
    print(d1.values())  # dict_values(['jason', 123])  老母猪  现在就把它当成一个列表来看即可
    
    print(d1.items())  # dict_items([('name', 'jason'), ('password', 123)])
    # 就把它看成是列表套元组,元组的第一个元素是字典的key 第二个元素是字典的value

          还可以通过get()方法根据key获取value。

    d1 = {'name':'jason','pwd':123}
    
    print(d1.get("name"))  # jason
    print(d1.get("pwd"))  # 123
    print(d1.get("xxx"))  # None  当key不在字典中时返回None
    
    # 可以在get中添加第二个参数,不管key在不在字典中,都返回所给的参数
    
    print(d1.get('name','你给我的name在字典的key中'))  # 你给我的name在字典的key中
    print(d1.get('xxx','你给我的xxx不在字典的key中'))  # 你给我的xxx不在字典的key中

        6、dict.fromkeys(),dict.popitem(),dict.update()

    # dict.fromkeys() 快速创建字典
    
    l1 = 'name', 'password', 'age', 'hobby'
    print(dict.fromkeys(l1, 123))  # {'name': 123, 'password': 123, 'age': 123, 'hobby': 123}
    l1 = ('name', 'password', 'age', 'hobby')
    print(dict.fromkeys(l1, 123))  # {'name': 123, 'password': 123, 'age': 123, 'hobby': 123}
    l1 = 'name'
    print(dict.fromkeys(l1, 123))  # {'n': 123, 'a': 123, 'm': 123, 'e': 123}

    # l1可以为一个可迭代的对象,例如字符串、列表、字典,列表和字典中的元素必须为不可变数据类型
    # dict.popitem()
    
    d1 = {'name': 123, 'password': 123, 'age': 123, 'hobby': 123}
    print(d1.popitem())  # 尾部以元组的形式弹出键值对 ('hobby', 123)
    # dict.setdefault()  添加新的键值对
    
    d1 = {'name': 'jason', 'pwd': 123}
    res1 = d1.setdefault('name', 'xxoo')  # 当键存在的情况下 不修改值 并且将原先key对应值返回给你
    print(d1, res1)  # {'name': 'jason', 'pwd': 123} jason
    res2 = d1.setdefault('age', 18)  # 当键不存在的情况下 新增一个键值对 并且将新增的键值对的值返回给你
    print(d1, res2)  # {'name': 'jason', 'pwd': 123, 'age': 18} 18
    d1 = {'name': 'jason', 'pwd': 123}
    d2 = {"num": 18}
    d1.update(d2)
    print(d1)  # {'name': 'jason', 'pwd': 123, 'num': 18} 当key不存在时,添加新的键值对
    d1.update(num=666)
    print(d1)  # {'name': 'jason', 'pwd': 123, 'num': 666} 当key存在时更新value
    d1.update(age=666)
    print(d1)  # {'name': 'jason', 'pwd': 123, 'num': 18, 'age': 666} 当key不存在时,添加新的键值对

        7、循环

          字典中的for循环打印得到是键key

    d1 = {'name': 'jason', 'password': 123}
    for i in d1:
        print(i)  # name password

      3、字典总结:字典可以存储多个值,字典内部的元素是没有顺序的,字典是可变数据类型

    4、集合及其常用的方法

      1、什么是集合:群体间作比较,不涉及单个元素

        1、集合的作用:可以用来去重,做一些关系比较

        2、集合的类型

    pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
    linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}
    
    s = {1,2,3,4,5,6}  # <class 'set'>  # s = set()

        3、集合的三个原则

          1、每个元素必须是不可变类型

    s = {1,2,3,4,5,6,'a',(1,2),[1,2]}  # 报错
    s = {1,2,3,4,5,6,'a',(1,2),{"name":'jason'}}  # 报错

          2、没有重复的元素

    s = {1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5}
    print(s)  # {1, 2, 3, 4, 5} 自动将重复的元素 去除

          3、无序

    s = {1, 2, 3, 4, 5, 6}
    print(s[1])  # TypeError: 'set' object does not support indexing
    
    # 注意集合的目的是将不同的值存放到一起,不同的集合间用来做关系运算,无需纠结于集合中单个值

        4、优先掌握的操作

          1、长度len

    s = {1, 2, 3, 4}
    print(len(s))  # 4

      2、成员运算in和not in(与列表、字符串中的成员运算方法相同),若查询的元素在集合中则返回True,反之返回False。

          3、|合集

    # 取出所有报了名的学生姓名

    pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
    linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}
    print(pythons | linux)  # {'tank', 'alex', 'frank', 'nick', 'egon', 'jerry', 'kevin', 'jason', 'owen'}

          4、&交集

    pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
    linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}
    
    # 既报名python也报名linux的学生姓名
    print(pythons & linux)  # 交集  {'tank', 'egon', 'alex'}

          5、-差集

    pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
    linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}
    
    # 只报名linux的学生姓名
    print(linux - pythons)  # {'jerry', 'frank'}

          6、^对称差集

    pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
    linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}
    
    # 没有同时报名两门课程的学生姓名
    print(pythons ^ linux)  # 对称差集 {'jerry', 'frank'}

          7、==

    s = {1, 2, 3}
    s1 = {3, 1, 2}
    print(s == s1)  # True

          8、父集:>,>=

    s1 = {1, 2, 3, 4, 55}
    s2 = {1, 2, 666}
    s3 = {1, 2}
    
    print(s1 > s2)  # False
    print(s1 > s3)  # True

          9、子集:<,<=:具体用法和父集相同

    s1 = {1, 2, 3, 4, 55}
    s2 = {1, 2, 666}
    s3 = {1, 2}
    
    print(s2 < s1)  # False
    print(s3 < s1)  # True

            PS:

            issubset():判断是否是子集

            issuperset():判断是否是父集

      2、集合总结:集合中每个元素必须是不可变类型,且没有重复的元素,元素都是无序的,集合本身是个可变数据类型。

    5、数据类型总结

      总共有八种数据类型,分别为int、float、str、list、dict、bool、tuple、set。

      可分为可变数据类型和不可变数据类型两大类:

      可变数据类型:list、dict、set

      不可变数据类型:int、float、str、tuple、bool

  • 相关阅读:
    二分图最大匹配的K&#246;nig定理及其证明
    HDOJ 2389 Rain on your Parade
    HDOJ 1083 Courses
    HDOJ 2063 过山车
    POJ 1469 COURSES
    UESTC 1817 Complete Building the Houses
    POJ 3464 ACM Computer Factory
    POJ 1459 Power Network
    HDOJ 1532 Drainage Ditches
    HDU 1017 A Mathematical Curiosity
  • 原文地址:https://www.cnblogs.com/le-le666/p/11134420.html
Copyright © 2011-2022 走看看