Python开发【第2篇】：Python数据结构

#参考：http://www.cnblogs.com/linhaifeng/articles/7133357.html#_label2

　　  　http://www.cnblogs.com/haiyan123/p/8387018.html

数据结构都有哪些？
　　数字类型 字符串 列表 元祖 字典 集合

按照以下几个点展开数据类型的学习

#一：基本使用
用途
定义方式
常用操作+内置的方法

#二：该类型总结
存一个值or存多个值
    只能存一个值
    可以存多个值，值都可以是什么类型
有序or无序
可变or不可变
    ！！！可变：值变，id不变。可变==不可hash
    ！！！不可变：值变，id就变。不可变==可hash

数字类型

分类：整型，布尔，浮点，复数    

整型与浮点型
#整型int
　　作用：年纪，等级，身份证号，qq号等整型数字相关
　　定义：
　　　　age=10 #本质age=int(10)

#浮点型float
　　作用：薪资，身高，体重，体质参数等浮点数相关

    salary=3000.3 #本质salary=float(3000.3)

#二进制，十进制，八进制，十六进制
1.bin()函数将十进制转换成而进制
    eg：print(bin(111))
2.oct()函数将十进制转换成八进制
    eg：print(oct(222))
3.hex()函数将十进制转换成十六进制     
    eg：print(hex(123))
    
　　　　十六进制表示：0-9 a b c d e f

4.数字类型的特性：    

　　　　只能存放一个值  

　　　　一经定义，不可更改

 　　　　直接访问
 
其他数字类型（了解）
#长整形（了解）
    在python2中（python3中没有长整形的概念）：　　　　　　
    >>> num=2L
    >>> type(num)
    <type 'long'>

#复数（了解）　　
    >>> x=1-2j
    >>> x.real
    1.0
    >>> x.imag
    -2.0

字符串

    引号包含的都是字符串类型

　　　　S1='hello world'  s="hello world"

　　　　s2="""hello world"""  

　　　　s3='''hello world'''  

　　单引双引没有区别

　　字符串的常用操作  

字符串的常用操作  
#作用：名字，性别，国籍，地址等描述信息

#定义：在单引号\双引号\三引号内，由一串字符组成
name='egon'

#优先掌握的操作：
#1、按索引取值(正向取+反向取) ：只能取
#2、切片(顾头不顾尾，步长)
#3、长度len
#4、成员运算in和not in

#5、移除空白strip
#6、切分split
#7、循环

需要掌握的操作：
    1、strip,lstrip,rstrip
    2、lower,upper
    3、startswith,endswith
    4、format的三种玩法
    5、split,rsplit
    6、join
    7、replace
    8、isdigit
常用操作注释：
    strip()移除空白，也可以去除其他的字符  

    slipt()分割,默认以空格分割。也可以以其他的字符分割  

    len()长度  切片：如print(x[1:3])也是顾头不顾尾   

    　　　　　　　     print(x[0:5:2])#0 2 4

    capitalize()首字母大写

    center()居中显示例如：x='hello'  print(x.center(30,'#'))

    count():计数，顾头不顾尾，统计某个字符的个数，空格也算一个字符  

    endswith()以什么结尾

    satrtswith()以什么开头

    find()查找字符的索引位置，如果是负数，代表查找失败   

    index()索引  

    find()和index()的区别，如下：
        name='egon say hello'
        print(name.find('o',1,5)) #顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引
        print(name.index('e',2,4)) #同上,但是找不到会报错

    format()字符串格式化    

    1.msg='name:{},age:{},sex:{}'           
        print(msg.format('haiyan',18,女))  

    2.msg='name:{0},age:{1},sex:{0}'     
        print(msg.format('aaaaaa','bbbbbb'))    

    3.msg='name:{x},age:{y,sex:{z}'     
        print(msg.format(x='haiyan',y='18',z='女'))  

    isdigit()判断是否是数字

    islower()判断是否是全部小写

    isupper()判断是否是全部大写

    lower()全部转换为小写

    upper()全部转换为大写

    isspace()判断是否是全都是空格

    istitle()判断是否是标题（首字母大写）  

    swapcase()大小写字母翻转

    join()连接

    repalce()替换   

    msg='hello alex'   

        print(msg.replace('e'),'A',1)  

        print(msg.replace('e'),'A',2)

    ljust()左对齐   

        X='ABC'    print(x.ljust(10,'*'))

1  %s,%d

举例1：name='egon'

　　　  age=20

　　　  print("my name is %s  my age is %s" %(name,age))#%s既能接受字符串，也能接受数字

　　　  print(‘my name is %s  my age is %d’ %(name,age))#%d只能接受数字

ps：format方法在上面已经涉及到了

举例2：用户信息的显示
while True:
    name=input("name:")
    age=input("age:")
    sex=input("sex:")
    height=input("height:")
    msg='''
             ------------%s info-----------
             name:%s
             age:%s
             sex:%s
             height:%s
             ------------------------------
        '''%(name,name,age,sex,height)
    print(msg)
#执行效果自己输入信息

　　示例：

示例：
    #strip
    name='*egon**'
    print(name.strip('*'))
    print(name.lstrip('*'))
    print(name.rstrip('*'))

    #lower,upper
    name='egon'
    print(name.lower())
    print(name.upper())

    #startswith,endswith
    name='alex_SB'
    print(name.endswith('SB'))
    print(name.startswith('alex'))

    #format的三种玩法
    res='{} {} {}'.format('egon',18,'male')
    res='{1} {0} {1}'.format('egon',18,'male')
    res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)

    #split
    name='root:x:0:0::/root:/bin/bash'
    print(name.split(':')) #默认分隔符为空格
    name='C:/a/b/c/d.txt' #只想拿到顶级目录
    print(name.split('/',1))

    name='a|b|c'
    print(name.rsplit('|',1)) #从右开始切分

    #join
    tag=' '
    print(tag.join(['egon','say','hello','world'])) #可迭代对象必须都是字符串

    #replace
    name='alex say :i have one tesla,my name is alex'
    print(name.replace('alex','SB',1))

    #isdigit：可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法
    age=input('>>: ')
    print(age.isdigit())

　　其他操作（了解即可）

#1、find,rfind,index,rindex,count
#2、center,ljust,rjust,zfill
#3、expandtabs
#4、captalize,swapcase,title
#5、is数字系列
#6、is其他

　　示例：

#find,rfind,index,rindex,count
    name='egon say hello'
    print(name.find('o',1,3)) #顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引
    # print(name.index('e',2,4)) #同上,但是找不到会报错
    print(name.count('e',1,3)) #顾头不顾尾,如果不指定范围则查找所有

    #center,ljust,rjust,zfill
    name='egon'
    print(name.center(30,'-'))
    print(name.ljust(30,'*'))
    print(name.rjust(30,'*'))
    print(name.zfill(50)) #用0填充

    #expandtabs
    name='egon\thello'
    print(name)
    print(name.expandtabs(1))

    #captalize,swapcase,title
    print(name.capitalize()) #首字母大写
    print(name.swapcase()) #大小写翻转
    msg='egon say hi'
    print(msg.title()) #每个单词的首字母大写

    #is数字系列
    #在python3中
    num1=b'4' #bytes
    num2=u'4' #unicode,python3中无需加u就是unicode
    num3='四' #中文数字
    num4='Ⅳ' #罗马数字

    #isdigt:bytes,unicode
    print(num1.isdigit()) #True
    print(num2.isdigit()) #True
    print(num3.isdigit()) #False
    print(num4.isdigit()) #False

    #isdecimal:uncicode
    #bytes类型无isdecimal方法
    print(num2.isdecimal()) #True
    print(num3.isdecimal()) #False
    print(num4.isdecimal()) #False

    #isnumberic:unicode,中文数字,罗马数字
    #bytes类型无isnumberic方法
    print(num2.isnumeric()) #True
    print(num3.isnumeric()) #True
    print(num4.isnumeric()) #True

    #三者不能判断浮点数
    num5='4.3'
    print(num5.isdigit())
    print(num5.isdecimal())
    print(num5.isnumeric())
    '''
    总结:
        最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
        如果要判断中文数字或罗马数字,则需要用到isnumeric
    '''

    #is其他
    print('===>')
    name='egon123'
    print(name.isalnum()) #字符串由字母或数字组成
    print(name.isalpha()) #字符串只由字母组成

    print(name.isidentifier())
    print(name.islower())
    print(name.isupper())
    print(name.isspace())
    print(name.istitle())

　　小练习：

    # 写代码,有如下变量,请按照要求实现每个功能 （共6分，每小题各0.5分）
    name = " aleX"
    # 1)    移除 name 变量对应的值两边的空格,并输出处理结果
    name = ' aleX'
    a=name.strip()
    print(a)

    # 2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果

    name=' aleX'
    if name.startswith(name):
        print(name)
    else:
        print('no')

    # 3)    判断 name 变量对应的值是否以 "X" 结尾,并输出结果

    name=' aleX'
    if name.endswith(name):
        print(name)
    else:
        print('no')

    # 4)    将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
    name=' aleX'
    print(name.replace('l','p'))

    # 5)    将 name 变量对应的值根据 “l” 分割,并输出结果。
    name=' aleX'
    print(name.split('l'))

    # 6)    将 name 变量对应的值变大写,并输出结果

    name=' aleX'
    print(name.upper())

    # 7)    将 name 变量对应的值变小写,并输出结果

    name=' aleX'
    print(name.lower())

    # 8)    请输出 name 变量对应的值的第 2 个字符?
    name=' aleX'
    print(name[1])

    # 9)    请输出 name 变量对应的值的前 3 个字符?
    name=' aleX'
    print(name[:3])

    # 10)    请输出 name 变量对应的值的后 2 个字符?

    name=' aleX'
    print(name[-2:])

    # 11)    请输出 name 变量对应的值中 “e” 所在索引位置?

    name=' aleX'
    print(name.index('e'))

    # 12)    获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。
    name=' aleX'
    a=name[:-1]
    print(a)

 列表

列表
    #作用：多个装备，多个爱好，多门课程，多个女朋友等

    #定义：[]内可以有多个任意类型的值，逗号分隔
    my_girl_friends=['alex','wupeiqi','yuanhao',4,5] #本质my_girl_friends=list([...])
    或
    l=list('abc')

    #优先掌握的操作：
    #1、按索引存取值(正向存取+反向存取)：即可存也可以取      
    #2、切片(顾头不顾尾，步长)
    #3、长度
    #4、成员运算in和not in

    #5、追加
    #6、删除
    #7、循环


    #ps:反向步长
    l=[1,2,3,4,5,6]

    #正向步长
    l[0:3:1] #[1, 2, 3]  1表示正向往后取值（从左到右取值）
    #反向步长
    l[2::-1] #[3, 2, 1]    -1表示反向取值，也就是从右往左取值
    #列表翻转
    l[::-1] #[6, 5, 4, 3, 2, 1]

　　练习：

    1. 有列表data=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量

    2. 有如下列表，请按照年龄排序（涉及到匿名函数）
    l=[
        {'name':'alex','age':84},
        {'name':'oldboy','age':73},
        {'name':'egon','age':18},
    ]
    答案：
    l.sort(key=lambda item:item['age'])    #item是自己随意写的（可换成任何字母），这意思就是在l的列表中，按照age进行排序
    print(l)

元组

    作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读

    定义：与列表类型比，只不过[]换成()
    age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))

    优先掌握的操作：
    1、按索引取值(正向取+反向取)：只能取   
    2、切片(顾头不顾尾，步长)
    3、长度
    4、成员运算in和not in
    5、循环

　　练习

    -简单购物车,要求如下：
    实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入　　

    msg_dic={
    'apple':10,
    'tesla':100000,
    'mac':3000,
    'lenovo':30000,
    'chicken':10,
    }
    
    答案：
    msg_dic={
    'apple':10,
    'tesla':100000,
    'mac':3000,
    'lenovo':30000,
    'chicken':10,
    }
    goods_l=[]
    while True:
        for key,item in msg_dic.items():
            print('name:{name} price:{price}'.format(price=item,name=key))
        choice=input('商品>>: ').strip()
        if not choice or choice not in msg_dic:continue
        count=input('购买个数>>: ').strip()
        if not count.isdigit():continue
        goods_l.append((choice,msg_dic[choice],count))

        print(goods_l)

字典

#作用：存多个值,key-value存取，取值速度快

#定义：key必须是不可变类型，value可以是任意类型
info={'name':'egon','age':18,'sex':'male'} #本质info=dict({....})
或
info=dict(name='egon',age=18,sex='male')
或
info=dict([['name','egon'],('age',18)])
或
{}.fromkeys(('name','age','sex'),None)

#优先掌握的操作：
#1、按key存取值：可存可取
#2、长度len
#3、成员运算in和not in

#4、删除
#5、键keys()，值values()，键值对items()
#6、循环

　　练习

1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中

即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}

》》》》》
a={'k1':[],'k2':[]}
c=[11,22,33,44,55,66,77,88,99,90]
for i in c:
    if i>66:
        a['k1'].append(i)
    else:
        a['k2'].append(i)
print(a)

2 统计s='hello alex alex say hello sb sb'中每个单词的个数

结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}
》》》》》
s='hello alex alex say hello sb sb'

l=s.split()
dic={}
for item in l:
    if item in dic:
        dic[item]+=1
    else:
        dic[item]=1
print(dic)

集合 

#作用：去重，关系运算，

#定义：
            知识点回顾
            可变类型是不可hash类型
            不可变类型是可hash类型

#定义集合:
            集合：可以包含多个元素，用逗号分割，
            集合的元素遵循三个原则：
             1：每个元素必须是不可变类型(可hash，可作为字典的key)
             2:没有重复的元素
             3：无序

注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
 

#优先掌握的操作：
#1、长度len
#2、成员运算in和not in

#3、|合集
#4、&交集
#5、-差集
#6、^对称差集
#7、==
#8、父集：>,>= #
#9、子集：<,<=

　　练习：

　一.关系运算
　　有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　　pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
　　linuxs={'wupeiqi','oldboy','gangdan'}
　　1. 求出即报名python又报名linux课程的学员名字集合
　　2. 求出所有报名的学生名字集合
　　3. 求出只报名python课程的学员名字
　　4. 求出没有同时这两门课程的学员名字集合
》》》》》》》
    # 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
    pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
    linuxs={'wupeiqi','oldboy','gangdan'}
    # 求出即报名python又报名linux课程的学员名字集合
    print(pythons & linuxs)
    # 求出所有报名的学生名字集合
    print(pythons | linuxs)
    # 求出只报名python课程的学员名字
    print(pythons - linuxs)
    # 求出没有同时这两门课程的学员名字集合
    print(pythons ^ linuxs)

 　　二.去重

　　 1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序

　　 2.在上题的基础上，保存列表原来的顺序

　　 3.去除文件中重复的行，肯定要保持文件内容的顺序不变
　　 4.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序

    l=[
        {'name':'egon','age':18,'sex':'male'},
        {'name':'alex','age':73,'sex':'male'},
        {'name':'egon','age':20,'sex':'female'},
        {'name':'egon','age':18,'sex':'male'},
        {'name':'egon','age':18,'sex':'male'},
    ]　
    》》》》》》
    #去重,无需保持原来的顺序
    l=['a','b',1,'a','a']
    print(set(l))    #set自带去重规则，可看源码（Build an unordered collection of unique elements.） 构建唯一元素的无序集合

    #去重,并保持原来的顺序
    #方法一:不用集合
    l=[1,'a','b',1,'a']

    l1=[]
    for i in l:
        if i not in l1:
            l1.append(i)
    print(l1)
    #方法二:借助集合
    l1=[]
    s=set()
    for i in l:
        if i not in s:
            s.add(i)
            l1.append(i)

    print(l1)


    #同上方法二,去除文件中重复的行
    import os
    with open('db.txt','r',encoding='utf-8') as read_f,\
            open('.db.txt.swap','w',encoding='utf-8') as write_f:
        s=set()
        for line in read_f:
            if line not in s:
                s.add(line)
                write_f.write(line)
    os.remove('db.txt')
    os.rename('.db.txt.swap','db.txt')

    #列表中元素为可变类型时,去重,并且保持原来顺序
    l=[
        {'name':'egon','age':18,'sex':'male'},
        {'name':'alex','age':73,'sex':'male'},
        {'name':'egon','age':20,'sex':'female'},
        {'name':'egon','age':18,'sex':'male'},
        {'name':'egon','age':18,'sex':'male'},
    ]
    # print(set(l)) #报错:unhashable type: 'dict'
    s=set()
    l1=[]
    for item in l:
        val=(item['name'],item['age'],item['sex'])
        if val not in s:
            s.add(val)
            l1.append(item)

    print(l1)






    #定义函数,既可以针对可以hash类型又可以针对不可hash类型
    def func(items,key=None):
        s=set()
        for item in items:
            val=item if key is None else key(item)
            if val not in s:
                s.add(val)
                yield item

    print(list(func(l,key=lambda dic:(dic['name'],dic['age'],dic['sex']))))

数据类型总结

按存储空间的占用分（从低到高）
    数字
    字符串
    集合：无序，即无序存索引相关信息
    元组：有序，需要存索引相关信息，不可变
    列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
    字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

按存值个数区分

    标量／原子类型    数字，字符串
    容器类型    列表，元组，字典
     

 

按可变不可变区分

    可变    列表，字典
    不可变    数字，字符串，元组
     

 

按访问顺序区分

    直接访问    数字
    顺序访问（序列类型）    字符串，列表，元组
    key值访问（映射类型）    字典

1.可变数据类型：在id不变的情况下，value可改变（列表和字典是可变类型，但是字典中的key值必须是不可变类型）

2.不可变数据类型：value改变，id也跟着改变。（数字，字符串，布尔类型，都是不可类型）

运算符

#身份运算（is ，is not）
is比较的是id，而双等号比较的是值
毫无疑问，id若相同则值肯定相同，而值相同id则不一定相同
>>> x=1234567890
>>> y=1234567890
>>> x == y
True
>>> id(x),id(y)
(3581040, 31550448)
>>> x is y
False

详细参考    http://www.cnblogs.com/linhaifeng/articles/5935801.html#_label34