Python内置数据结构

分类

• 数值型
  • int、float、complex、bool
• 序列对象
  • 字符串 str
  • 列表 list
  • 元组 tuple
• 键值对
  • 集 set
  • 字典 dict

数值型

• 数值型
  • int、float、complex、bool都是类(class),1、5.0、1+2j都是对象即实例
  • int：在python3版本中表示长整型，没有大小限制，受限制于内存区域大小
  • float:浮点数由整数部分和小数部分组成，支持十进制和科学计数法表示，在python中只有双精度浮点数
  • complex：复数由实数和虚数部分组成，实数和虚数都是浮点数，例：3+4.2j
  • bool：int的子类，基友两个实例True和False，分别代表1和0，可以直接和整数计算
• 类型转换
  • int(x) #返回一个整数
  • float(x) #返回一个浮点数
  • complex(x)/comples(x,y) #返回一个复数
  • bool(x) #返回布尔值，对应关系可查看真值表
• 数字的处理函数
  • python中管与数学处理的模块math需要单独导入(import math)，math.floor表示舍去小数部分的值取整，math.ceil表示只要小数位不是零则一律进1
  • int() #将括号内的浮点数小数点后的数值舍掉，只取整数部分
  • round() #这个函数去正式遵循四舍六入，当小数点后为5时，取离得最近的偶数值

  可以测试下如下代码:
  - print(math.ceil(2.1))
  - print(math.floor(2.9))
  - round(2.5)
  - round(3.5)
  - round(3.4)
  - round(3.6)
  
  - min() #取括号内数字的最小值
  - max() #取括号内数字的最打值
  - pow(x,y) #取x的y次方
  - math.sqrt(9) #取就得0.5次方，也就是√-3
  - math.pi #取π的值3.141592653589793
  - math.e #取自然常数的值2.718281828459045

  • 转换进制
    • bin() #转换为二进制字符串
    • oct() #转换位八进制字符串
    • hex() #转换为十六进制字符串
• 类型判断
  • type(object),返回类型，而不是字符串 例：type(a)、type(‘b’)、type(123) type(1+True+3.0)返回的类型是浮点型，这是应为因为在数学计算中包含一个隐式转换，由精度低的数项精度高的数转换
  • isinstance(obj,class_or_tuple),判断参数是不是后面其中一个的类型，返回布尔值 例：isinstance(6,str) isinstance(6,(str,bool,int,float))

列表(list)

• 列表的特性
  • 一个队列，排列整齐的队伍
  • 列表里的个体称为元素(item)，有若干元素组成
  • 元素可以式任意的数字、字符串、对象、列表等
  • 列表内元素有顺序，可以使用索引
  • 属于线性数据结构
  • 使用[]表示，[]空的中括号表示空列表
  • 列表是可以变化的,可以增、删、改、查和追加
• 列表list、链表(linklist)、队列(queue)、栈(stack)的差异
  • 列表是有序地，一个接一个排列的集合，每一个元素占据一个单位，就像书本一样，一页内容对应一个页码，可以通过索引来查找
  • 链表是有连接的，一个连一个的，好比手拉手，通过前一个元素可以找到下一个元素
  • 队列可以是列表，也可以是链表，他可以项放行一样先进先出，也可以像解散一样后进先出
  • 栈 是以类似重叠的方式排列，就像摞盘子一样是典型的后进先出队列
• 列表list定义、初始化
  • list() -> new empty list
  • list(iterable) -> new list initialized from iterable’s items(从可迭代的元素初始化列表)
  • 列表不能一开始就定义大小这是Python中的列表特性，它是可变化的
  • 列表的元素也可以是函数的结果
• 列表索引访问
  • 索引(index),也叫下标
  • 正索引：从左到右，从0开始，是列表中每一个元素的编号
  • 负索引：从右到左，从-1开始
  • 正负索引不能超超界，超界后报错IndexError
  • 默认认为列表是从左往右排列的，左边头部右边尾部，左边下界右边上界
  • 列表可以通过索引来访问，格式为listname[index],index就是索引，是指某个元素在列表中的位置，默认从0开始

  In [4]: lst
  Out[4]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  
  In [5]:
  
  In [5]: lst[6]
  Out[5]: 6
  
  In [6]:

• 列表查询
  • index(valiue,[start,[stop]]) 1.通过值value，从指定区间查找列表的元素是否匹配 2.匹配第一个值就返回索引 3.匹配不到，显示valueError
  • count(value) 返回列表中匹配到的值得次数
  • 时间复杂度 1.index和count的方法复杂度是O(n)，O(1)这个是表示效率最高，一步操作；count的时间复杂度是O(n)表示所有元素查看一遍或者叫遍历，有n个元素就做n次操作 2.随着数据规模的增大，效率会越来越低
  • 函数len() 查询项目中元素的个数，是公共的内建函数，可以查询类似集合的元素数量
• 查询帮助
  • 查看帮助文档
  • 查看官方文档
  • 在ipython中通过help(keyword)
    • keyword可以是函数、类、对象、变量、方法名
• 列表元素修改 当操作修改列表完成时若返回none值则没有新列表生成，是为就地修改
  • 索引访问修改 list[index]=value,索引不能超界，否则就提示异常 -列表增加，插入元素

    1. append(object) #尾部追加，不会生成新的列表，时间复杂度O(1)
    2. insert(index,object) #在指定索引处插入一个值，索引开始到最后的元素整体后移一个单位，索引超下界会在头部追加，超上界尾部追加。由于操作会硬气内存结构的变化，所以一般不使用
    3. extend（iteratable） #列表扩展：将可迭代对象的元素追加进来，就地修改
    4. list1+list2 #连接操作，将两个列表连接起来，产生新表，原列表不变
    5. list*num #重复操作，将本列表元素重复n次，返回新的列表

  • 列表删除元素

    1. remove(value) #从左往右查找第一个匹配的值并移除，就地修改
    2. pop([index]) #不指定索引，从列表哦尾部弹出一个元素，或者制定索引，从指定索引出弹出元素
    3. clear() #清楚对象列表中的所有元素，剩下一个空列表

  • 列表其他操作

    1.reversed() #将列表中元素颠倒顺序，就地修改
    2.sort(key=None,reverse=False) #对列表惊醒排序，就地修改，默认升序；reverse=True,就是反转并按降序排列；key可以制定一个函数，指定key如何排序
    3. in 查看一个元素在不在一个列表中；而for x in [1,2,3,4]表示从列表中取出元素附给x

• 列表复制
• copy() #shadown cpoy(影子复制),也叫浅拷贝，遇到引用类型，只是复制了一个引用，如果引用的对象被修改，则两个列表所引用的元素都会改变，
• 深拷贝，copy模块提供深拷贝，深copy会在内存中新建一个列表，并赋值

随机数

random模块 1.random.randint(a,b) #返回[a,b]之间的整数 2.random.choice(seq) #从非空序列中随机挑选一个元素 3.randrange([start,]stop[,step]) #从指定按制定奇数递增的集合中获取一个随机数，默认奇数为1 4.random.shuffle(list) #就地打乱列表元素

练习

1.求100内的素数

lst=[2]
for i in range(3,100,2):
    for n in lst:
        if i%n ==0:
            break
    else:
        #print(i)
        lst.append(i)   #将计算出的素数追加到素数列表中
print(lst)

import math 
pn=[]
for x in range(3,1000,2):
    for i in pn:
        if x%i==0:
            sign=True
            break
        if i>=math.ceil(x**0.5):
            sign=False
            break
    if not sign:   #只有是真值的时候，才会执行及里边的语句块，当flag为False，not flag是True,程序才会进去if内部语句块，否则就继续下面的语句
        #print(x)
        pn.append(x)
print(pn)

2.计算杨辉三角的前六行

triangle=[[1],[1,1]]
for i in range(2,6):
    p = triangle[i-1]
    cur=[1]
    for j in range(0,i-1):
        cur.append(p[j]+p[j+1])
    cur.append(1)
    triangle.append(cur)
print(triangle)

triangle=[]
for i in range(6):
    if i==0:
        lr=[1]
        triangle.append(lr)
    else:       
        p=triangle[i-1]
        cur=[1]
        for j in range(0,i-1):
            cur.append(p[j]+p[j+1])
        cur.append(1)
        triangle.append(cur)
print(triangle)

triangle=[]
for i in range(6):
    if i==0:
        lr=[1]
        triangle.append(lr)
    else:
        p=[0]
        p.extend(triangle[i-1])
        p.append(0)
        cur=[]
        for j in range(0,i+1):
            cur.append(p[j]+p[j+1])
        triangle.append(cur)
print(triangle)

triangle=[]
for i in range(6):
    if i==0:
        lr=[1]
        triangle.append(lr)
    elif i==1:
        lr=[1,1]
        triangle.append(lr)        
    else:       
        p=triangle[i-1]
        cur=[1]
        x=1
        while x<=(i-1):
            cur.append(p[x-1]+p[x])
            x+=1
        cur.append(1)
        triangle.append(cur)
print(triangle)

方法二

ol=[]
nl=[1]
print(nl)
for i in range(1,6):
    ol=nl.copy()
    ol.append(0)
    nl.clear()
    offset=0
    while offset<=i:
        nl.append(ol[offset-1]+ol[offset])
        offset+=1
    print(nl)

元组(tuple)

元组是一个有序的元素组成的集合，使用()表示，元组是不可变对象，包括元祖的的长度和元素本身。如果元祖中的元素是一个引用对象，当引用对象本身发生变化是，元组中的元素才会发生变化。

• 定义
  • tuplename=tuple() #定义一个空元组，括号里可以是可迭代对象、数字、字符串、列表等
  • tuplename=tuple(2,) #当定义一个元素的元组时，要在元素后加个逗号，否则会提示括号所在的类不是一个可迭代对象
  • tuple和list一样，可以使用‘+’连接两个不同的元组，创建一个新的元组打印出来，也可以通过‘*’创建一个被乘的元组重复几次的新元组打印出来。
  • 元祖也支持索引访问，包括正负索引，其访问的方式和列表一样，但是索引不能超界，否则引发异常
  • tuplename.index(9) #在tuplename这个元组中查看9的索引，会返回从左到右最近的匹配到的9的索引，匹配不到就返会valueerror。
  • tuplename.count(9) #在tuplename这个猿族中查询9这个值在元组中出现了几次
  • len(tuplename) #查询元祖的长度或者说是元组中元素的个数
  • 元组类似于只读权限的文件，这可以读取，不能增改删，只能删除整个元组
• 命名元组namedtuple
  • namedtuple使用时需要执行命令“from collections import namedtuple”
  • namedtuple(typename,field_names（可以是空格或者逗号分隔的字段的字符串，也可以是字段的列表）,verbose=FaLse,rename=False) #命名元组，返回元组的子类，并定义字段 例： “` In [2]: from collections import namedtuple

    In [3]: Point=namedtuple('_Point',['x','y'])
    
      In [4]: p=Point(11,22)
    
      In [5]: p.x
      Out[5]: 11
    
      In [6]: p.y
      Out[6]: 22
    
      ```

• 练习
  • 以此接收用户输入的3个数，排序后打印
    1. 转换int后，判断大小排序
    2. 使用max函数
    3. 使用列表的sort方法
    4. 冒泡法

字符串

字符串是有序的字符集合或者称字符序列，支持使用索引访问，是一个可迭代的对象

• 字符串join连接 python种特殊字符需要转义后使用

  例：
  In [15]: lst
  Out[15]: ['1', '2', '3']
  
  In [16]: print('/'.join(lst))
  1/2/3
  
  In [17]: print('\\'.join(lst))
  1\2\3
  
  In [18]: print('"'.join(lst))
  1"2"3

• • 连接符 和列表的用法一样，在这里是将两个字符串连接到一起返回一个新字符串
• 字符串分割 1.split系：将字符分割成若干字符串，并返回列表。

  格式
  - (string's name).split(sep=None,maxsplit=-1)
  分割时时从左向右sep制定分割字符串，默认时空白字符串作为分隔符；maxsplit制定分割次数，-1表示便利整个字符串。
  - (string's name).rsplit(sep=None,maxsplit=-1)
  从右向左
  - (string's name).splitlines([keepends])
  按照行来切分字符串，keepends指的是是否保留行分隔符（\n、\r\n、\r等）

  2.partittion系：将字符串按照分隔符分成两段，放回这两段和分割符的元组

  - partition(sep（必须指定）)
      从左到右，遇到分隔符就把字符串分成两部分，返回头(head)、分隔符、尾（tail）三部分的三元组；如果没有找到分隔符，就返回头、2个空元素的三元组
  - rpartition(sep)
      从右到左，功能同上

• 字符串大小写
  • upper() 全大写
  • lower() 全小写
  • swapcase() 交互大小写，就是大写变小写，小写变大写。
• 字符串排版
  • title 标题的每个单词首字母大写
  • capitalize 第一个单词首字母大写
  • center(width[,fillchar]) 打印字符串时居中打印，用多少个字符的宽度如果字符串不够用某个字符填充，默认字符是空格
  • zfill(width) 右对齐打印，左边字符不够的用0填充
  • ljust/rjust(width[,fillchar]) 左/右对齐打印
• 字符串修改

  - replace(old,new[,count]) 替换
      在字符串中找到指定字符串，替换为新字符串，返回新字符串，count表示替换几次
  - strip([chars]) 去除
      从字符串两端去除指定字符集chars中的所有字符串，如果chars没有指定则去除空白字符，同样有两种变体：lstrip/rstrip 从左/右开始去除
  - find(sub[,start[,end]]) 查找字符串
      在指定区间从左到右查找子串sub，找到则返回索引，没有就返回-1
      变体rfind：从右到左查找
  - index(sub[,start[,end]])  查找字符串
      在指定区间从左到右查找子串sub，找到则返回索引，没有就返回ValueError
      变体rindex：从右到左查找
  - count(sub[,start[,end]]) 统计
      在指定区间从左到右统计子串sub出现的次数
  - endwith/startwith([char,start[,end]]) 字符串判断
      在指定的区间中，字符串是否以指定的字符串开头或者结尾，返回bool值
  - ismetacharacters() 判断字符串有那些字符组成
      metacharacters可以时alpha、num、decimal、digit、dentifier、lower、upper、space等

• 字符串格式化 字符串格式化是指将字符串以特定的输出样式输出的书法

1. join连接只能使用分隔符，但是连接的对象必须是可迭代对象
2. ’+‘连接字符串比较方便，但是只能连接字符串

• printf style

  在python2.5版本之前只能使用printf style（C语言风格）的方式来格式化
  格式要求
      占位符，使用%和格式字符组成
          1.s掉用str()表示字符串;r调用repr(),表示对象通过repr函数转换为字符串；d调用int(),表示数字
          2. 占位符中汗可以插入修饰字符，例如%03d表示打印的字符站三个字符的位置，不够的前面用0补齐

• python自用的格式化字符串的语法

  '{}{xxx}'.format(*args,*kwargs)
          1. args是位置参数，是个元组
          2. kwargs是关键字参数，是个字典
          3. 大括号表示占位符
          4. {}表示按照顺序匹配位置参数，{n}表示取位置参数索引n的值
          5. {{}}表示打印大括号
          6. {xxx}表示在关键字仲搜索名称一致的
          7. {lst[0]}表示访问对象元素
          8. {p.x}表示对象属性访问
      例：
      '{}:{}'.format('192.168.1.100',8888)  按位置参数匹配
      '{server}{1}:{0}'.format(8888,'192.168.1.100',server='Webserver') 匹配关键字参数或命名参数
      对齐
      '{0}*{1}={2:<2}'.format(3,2,3*2)
      '{0}*{1}={2:<02}'.format(3,2,3*2)
      '{0}*{1}={2:>02}'.format(3,2,3*2)
      '{:^30}'.format('Internet Data Center') 表示占用30个字符居中对齐，不够的用空白字符填充
      '{=:^30}'.format('Internet Data Center')  表示占用30个字符居中对齐，不够的用=字符填充
      进制转换
      '{0:d/x/o/b/X}'.format(99)   d表示十进制，x/X表示十六进制小/大写，o表示八进制，b表示二进制

练习

• 用户输入一个数字
  • 判断是几位数
  • 打印每一位数重复次数
  • 按照个十百千万顺序打印每一位上的数字

num=''
while True:
    num=input('Enter:').strip()
    if num.isdigit():
        break
    else:
        print('please Enter number')

count=[0]*10

for i in range(10):
    count[i]=num.count(str(i))
for i in range(10):
    if count[i]:
        print(i,count[i])
lst=list(num)
lst.reverse()
print(lst)

• 输入五个数字，打印每个数字的位数，将这些数字按升序排列打印

列表排序
n=''
lst=[]
wsl=[]
c=0
while c<=4:
    n=input('Enter:')    
    lst.append(int(n))
    wsl.append(len(n))
    c+=1
print(wsl)
lst.sort()
print(lst)