• python学习day7 数据类型及内置方法补充


    http://www.cnblogs.com/linhaifeng/articles/7133357.html#_label4

    1。列表类型

    用途:记录多个值(一般存放同属性的值)

    定义方法

    在[]内用逗号分隔多个任意类型的值

    l=list{'hello'}

    l=list({'x':1,'y':2})

    print(l)

    常用操作+内置的方法

    优先掌握的操作:

    l=['a','b','c','e']

    按索引存取值(正向存取+反向存取):即可存也可以取

    print(l(0))

    print(l[-1])取最后一个元素

    print(id(l))

    l[0]='A'

    print(id(l))

    l[4]='EEEEE' 会修改值

    l[5]='ddddd'索引不存在的值回报错

    切片(顾头不顾尾,步长)
    l=['a','b','c','d','e']

    print(l[1:4])从索引开始输出,到索引4截止

    print(l)

    求长度 len

    l=['a','b','c','d','e']

    print(len(l))

    成员运算符 in和not in

    print('a' in l)

    print('a' not in l)

    追加和插入

    l=['a','b','c','d','e']

    l.append(4444),在列表末尾加上添加的内容g

    print(l)

    l.insert(0,1111111)在索引0的位置添加上要添加的内容

    print(l)

    删除

    l=['a','b','c','d','e']

    del l[0] 删除索引值对应的元素,假如索引值超过列表长度也会报错

    res=l.remove('b') 假如要删除的内容不在l中,会报错

    print(l)

    print(res)成功remove的话会返回None

    res=l.pop(0)删除索引对应的值

    print(l)

    print(res)#pop会把删除的值取回

    循环

    l=['a','b','c','d','e']

    for item in l:

      print(item)

    需要掌握的操作

    l=['a','b','a','c','d','e']

    print(l.count('a')) 计算字符出现的次数

    l=['a','b','a','c','d','e']

    items=[1,2,3,4,5]

    for item in items:

      l.append(item) 把另一个列表内添加进一个列表中

    也可以用extend把另一个列表添加进列表中

    l.extend(items) 本身返回值None

    print(l)

    l=['a','b','a','c','d','e']

    print(l.index('a',2,5))从索引2开始到索引5找值‘a',找到就返回’a'的索引

    l.index(234234234) 索引没找到值会报错

    if 234234234 in l:

      print(l.index(234234234))

    l=['a','b','a','c','d','e']

    l.reverse()

    print(l)反转列表l的内容

    l=[10,-1,3,11,9]

    l.sort()

    print()从小打到排列l

    l.sort(reverse=True)从大到小排列l

    print(l.extend(['a','b','c']))返回值None

    print(l.pop())返回删除的值

    总结:

    存多个值

    可变类型(1.可变:值变,id不变。可变==不可hash 2.不可变:值变,id就变。不可变=可hash)

    有序

    练习题;

    队列:先进先出

    l=[]

    入队

    l.append('first')

    l.append('secord')

    l.append('third')

    出队

    l.pop(0)

    l.pop(0)

    l.pop(0)

    堆栈:后进先出

    l.append('first')

    l.append('second')

    l.append('third')

    l.pop()

    l.pop()

    l.pop()

    2.元组类型

    用途:元组就是一个不可变的列表

    定义方法:在()内用逗号分隔开多个任意数据类型的元素

    t=(1,2.2,'aa',('b','c'),['a','b','c'])

    print(type(t))

    l=['a']这是定义了一个列表,只有一个元素,就是‘a'

    print(type(l),l[0]) 

    t=('a',),只有一个字符串的时候要用圆括号带逗号的形式定义,否则会定义成字符串类型

    print(type(t))

    print(t)

    msg=('hello world')

    类型转换

    t1=tuple('hello world')

    t2=tuple([1,2,3])能在for循环中循环的元素都可以放在tuple中,会循环取出后面的元素,组成一个元组

    print(t1)

    print(t2)

    常用操作和内置的方法

    优先掌握的操作:

    t=(1,2.2,'aa',('b','c'),['a','b','c'])

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

    print(t[0])

    print(t[-1])

    t[0]=111111 # 无法运行,报错,因为元组是不可变了类型

    切片(顾头不顾尾,步长)

    t=('a','b','c','e','f')

    print(t[1:4])从索引1开始取值,到索引4截止

    求长度

    print(len(t))

    成员运算符in和not in

    print('a' in t)

    循环

    for item in t:

      print(item)

    需要掌握的操作

    t=('a','b','c','e','a','f')

    print(t.index('a',1,5))从索引1位置开始找’a'对应的索引,到5截止。没找到该值的话会报错

    print(t.count('a'))计算‘a'出现几次

    总结:

    可以存多个值

    有序

    不可变类型(值变,id也改变)元组中索引于值的对应关系不能改变,如果元素中有列表,但是列表内 的元素可以修改,因为元组中索引与列表内存地址的对应关系没有改变

    t=('a','b','c')

    print(id(t))

    t=('A','B','C')

    print(id(t))

    t=('a',111,['b','c'])

    print(id(t[0],id(t[1]),id(t[2]))

    t[2][0]='B'

    print(t)

    print(id(t[0]),id(t[1]),id(t[2]))

    t[0]='A' #不能执行,会报错,因为会修改索引和内存地址的对应关系

    t[2]=[1,2,3] #同理不能运行

    l=['a','b','c']

    l[0]='A' 列表类型就可以随意更改了

    3.字典类型 dict

    用途:记录多个值,列表用索引取值,而字典用key对应值,其中key对value有描述性的作用

    4.定义方法:在{}用逗号分隔开多个元素,每个元素都是key:value的形式,其中key可以为不可变类型通常是字符串类型,而value可以是任意类型

    d={1:'aaa',2.2:'bbb','xxx':'ccc',(1,2,3):'dddd'} # d=dict{}

    print(d[(1,2,3)])

    类型转换

    d=dict(x=1,y=2,z=3) 前面的变量名是key,后面的值是value

    print(d)

    items=[('name','egon'),('age',18),('gender','male')]

    d={}

    for item in items: #items是一个列表,这个循环会按,号分隔取出列表中的元素,赋值给item,取出的item是元组,索引可以继续按索引操作

      d[item[0]]=item[1] #元组的第一个元素做key,第二个元素做value

    d=dict(items)(相当于上面的循环,把列表中的key和value取出来,对列表中值的格式有要求)

    print(d)

    了解

    keys=['names','age','gender','height','weight']

    d={}

    for key in keys:

      d[key]=None 用循环先建立一个value为空的字典

    d={}.fromkeys(key,None) 从key列表中去key,value先设为None

    常用操作+内置方法

    优先掌握的方法:

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

    dic={'name':'egon','age':18}

    dic['name'] 取不到值时报错

    print(dic.get'name')取不到值时返回None

    print(dic['name'])

    dic['name']='EGON'

    dic['gender']='male'#对于字典中没有的key和值,会直接添加进字典

    l=['a','b','c']

    l[0]='A'

    l[4]='AAA' 列表类型这样操作就会报错,找不到索引值

    求长度

    len

    dic={'name':'egon','age':18}

    print(dic)

    print(len(dic)) 返回key的个数,也是value个数

    成员运算符 in 和not in:是以字典的key为准的

    dic={'name':'egon','age':18}

    print('name' in dic) 判断是否是key

    print('egon' in dic)

    删除

    dic={'name':'egon','age':18}

    del dic['name'] #key如果不存在就报错,如果存在就把key和对饮的value一起删除

    print(dic)

    res=dic.pop('name') 同样是删除key和对应的value,但是会返回删除的value

    res=dic.popitem() 随机删除字典的一个key和value,把删除的key和value转成一个元组

    print(res)

    键keys(),值values(),键值对items()

    python2中

    # >>> dic={'name':'egon','age':18}
    # >>>
    # >>>
    # >>> dic.keys()
    # ['age', 'name']
    # >>>
    # >>>
    # >>> dic.values()
    # [18, 'egon']
    # >>>
    # >>>
    # >>> dic.items()
    # [('age', 18), ('name', 'egon')]

    # 在python3
    # >>> dic={'name':'egon','age':18}
    # >>>
    # >>> dic.keys()
    # dict_keys(['name', 'age'])
    # >>> dic.values()
    # dict_values(['egon', 18])
    # >>> dic.items()
    # dict_items([('name', 'egon'), ('age', 18)])

    循环
    dic={'name':'egon','age':18}
    for k in dic:
      print(k) #输出key
    for k in dic.keys():
      print(k)#输出key

    for v in dic.values():
      print(v) #输出value
    for k,v in dic.items():
      print(k,v)

    需要掌握的操作
    dic={'name':'egon','age':18}
    当key存在时,不改原值,返回原值
    res=dic.setdefault('gender','male')
    print(dic)
    print(res)
    当key不存在时,增加新值
    res=dic.setdefault('gender','male')
    print(dic)
    print(res)

    总结:
    可变类型
    存多个值
    无序

    4.集合类型set
    pythons=['张铁蛋','李铜淡','王金蛋','赵银胆','alex','kevin']
    # linuxs=['oldboy','张铁蛋','赵银胆','alex','wxx']
    #
    # res=[]
    # for stu in pythons:
    # if stu in linuxs:
    # res.append(stu)
    #
    # print(res)

    用途:1.关系运算 2.去重

    定义方法:在{}内用逗号分隔开多个元素,但是元素的特点是
    1.集合内元素必须是不可变类型
    2.集合内元素无序
    3.集合内元素不能重复
    s={1,'aaa',2}#s=set(...)
    print(s,type(s))
    s={1,1,1,1,1,1,1,'a','a','a'}
    print(s)#会去重

    数据类型转换
    res=set('hello')
    print(res) #会把字符串中每个字符单独取出来,存成一个集合

    res=set([1,'a','b'])
    print(res)#会把列表中元素一次取出存成集合
    
    常用操作+内置方法
    优先掌握的操作

    长度len
    成员运算in和not in
    pythons={'张铁蛋','李铜淡','王金蛋','赵银胆','alex','kevin'}
    linuxs={'oldboy','张铁蛋','赵银胆','alex','wxx'}
    #3、|合集:求所有报名的学生
    # print(pythons | linuxs)
    # print(pythons.union(linuxs))

    #4、&交集:求同时报名两门课程的学生
    # print(pythons & linuxs)

    #5、-差集: 求只报名python课程的学员
    # print(pythons - linuxs)
    # print(linuxs - pythons) #求只报名linux课程的学员

    #6、^对称差集:求没有同时报名两门课程的学生
    # res=(pythons - linuxs) | (linuxs - pythons)
    # res=pythons ^ linuxs
    # print(res)

    == 判断是否内容相同
    s1={1,2,3}
    s2={3,2,1}
    print(s1==s2)


    父子集描述的是一种包含和被包含的关系
    父集:>=
    子集: <=
    # s1={1,2,3}
    # s2={1,2,3,4}
    # print(s2 >= s1)
    # print(s1 <= s2)
    需要掌握的
    s1={1,2,3}
    s1.update(3,4,5,6)
    print(s1) 会把s1中没有的元素加进去

    s1={1,'aa','bb',3}
    print(s1.pop()) 随意扔一个值,返回被扔的值

    res=s1.remove('bbbb')如果集合中没有这个值,会报错
    print(s1)
    print(res)如果删除成功的话返回None

    s1.discard('bbb')没有这个值可以删除的话,返回None,不会报错
    s1.add(4) 如果集合里没有该值,就添加进去,返回None
    print(s1)


    总结
    存多个值
    无序
    可变

    集合的去重
    局限性
    1.只能针对不可变类型
    2.不能保证原来的顺序
    names=['egon','egon','egon','alex','alex','kevin']

    new_names=list(set(names))
    print(new_names)
    l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'kevin','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    ]
    new_l=[]
    for dic in l:
      if dic not in new_l:
        new_l.append(dic)

    print(new_l)
  • 相关阅读:
    ha-wordy-Write-up
    HA: Infinity Stones-Write-up
    为什么k8s引入pod概念?
    vxlan 跨网段虚拟机迁移
    交换机配置
    Git四大组件(转)
    php-fpm
    docker容器中用户自定bridge网络与默认bridge网络之间的区别
    原型链
    'style-loader', 'css-loader'使用
  • 原文地址:https://www.cnblogs.com/shanau2/p/10002823.html
Copyright © 2020-2023  润新知