元组

元组 tuple

特点

   1.一个有序的元素组合成的集合
   2.使用（）表示
   3.元组是不可变对象
        t3=（1，）表示的是一个元素
   4.一旦赋值不可相加

元组的定义初始化

定义

    1.tuple() -> empty tuple
    2.tuple(iterable)-> tuple initiialized from iterable's items
t = tuple # 工厂方法
t =  ()
t =  tuple(range(1,7,2)) #iterable
t = (2,4,6,3,2)
t = (1,) # 一个元素元组的定义注意有逗号
t =  (1,)*5
t = (1,2,3)*6

元组元素的访问

     1.支持索引（下标）
     2.正索引：从左至右，从0开始，为列表中的每一个元素编号
     3.负索引：从右至左，从-1 开始
     4.正负索引不可以超界，否则引发异常InderError
     5.元素通过索引访问
         tuple[index],index就是索引，使用中括号访问

元组查询

      1.index(value,[start,[stop]])
         (1)通过值value，从指定区间查找列表内的元素是否匹配
         (2)匹配第一个就立即返回索引
         (3)匹配不到抛出异常ValueError
      2.cont(value)
         (1)返回列表中匹配Value的次数
      3.时间复杂度
         (1)index和count方法都是O(n)
         (2)随着列表数据规模的增大，而效率下降
      4.len (tuple)
          (1)返回元素的个数

元组的其他操作

元组是只读的，所以增、删、改方法都没有

命名元组

 namedtuple(typname,field_name,verbose=False,rename=False)
     （1）命名元组，返回一个子类，并定义了字段
     （2）field_nameds可以是空白字符或者逗号分割开的字段的字符串，可以是字段的列表
     from collections import namedtuple
     Point = namedtuple('Point',['x','y'])  #Point为返回的类
     p=Point(11,22)
     Student = namedtuple('Student','name age')
     tom = Student('tom',20)
     jerry = Student('jerry','18')
     print(tom.name,jerry.age)
      (3)如同元组一样，命名元组的属性们的值不可变

冒泡法

定义

    1.属于交换排序
    2.两两比较大小，交换位置，如同水咕嘟咕嘟冒泡往上窜
    3.结果分为升序和降序排列

升序

     n个数从左至右，编号从0开始到n-1，索引0和1的值比较，如果索引0大则两者交换位置，
     如果索引1大则不交换。继续比较索引1和2的值，将大值放在右侧，知道n-1和n-2比
     较完，第一轮比较完，第二轮从索引0比较到n-2，因为最右侧n-1的位置上已经是最大值
     ，以此类推，每一轮都会减少最右侧的不参与比较，至只剩下最后两个数比较
  降序和升序相反

冒泡法总结

    1.  冒泡法需要数据一轮一轮的比较
    2.可以设定一个标记判断次轮是否有数据交换发生，如果没有发生数据交换可以结束排序，
    如果发生交换继续进行下一轮数据排序
    3.最差的排序情况是，初始顺序与目标顺序完全相反，遍历次数1......（n-1)之和n(n-1)/2
    4.最好的排序情况是，初始顺序与目标顺序完全相同，遍历次数n-1
    5.时间复杂度O(n**2)

字符串

特点

    1.一个个字符串组成的有序的序列，是字符的结合
    2.使用单引号、双引号、三引号引住的字符序列
    3.字符串是不可变对象
    4.Python3起字符串就是Unicode类型，

字符串元素访问——下标

    1. 字符串支持使用索引访问
    2.有序的字符结合，字符序列
    3.可迭代

字符串join连接

“string”.join(iterable) ->str

    1.将可迭代对象连接起来，使用string作为分隔符
    2.可迭代对象本身元素都是字符串
    3.返回一个新字符串

字符串+连接

+ -> str

    1.将两个字符串连接起来
    2.返回一个新字符串

字符串分割

分割字符串的方法分为两类

split系

     1. 将字符串按照分隔符分割成若干字符串，并立即返回列表

split（sep=None,maxsplit=-1）—> list of strings

     1.从左至右
     2.sep 指定分割字符串，缺省情况下空白字符串作为分隔符
     3.maxsplit 指定分割次数，-1表示遍历整个字符串

rsplit(sep=None,maxsplit=-1) -> list of strings

     1.从右向左开始切，但是输出的字符串字符不会反
     2.sep指定分割字符串，缺省的情况下空白字符串作为分隔符
     3.maxsplit 指定分隔的次数，-1表示遍历整个字符串

splitlines ([keepends]) -> list of strings

     1.按照行来切分字符串
     2. keepens 指定的是是否保留行分隔符
     3.分隔符包括\n、\r\n、\r等

partiton系

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

partition（sep）->(head,sep,tail)

      1.从左至右，遇到分隔符就把字符串分割成两部分，返回 头、分隔符、尾三部分的三元组：
      如果没有找到分隔符，就返回头、两个空元素的三元组
      2.sep 分割字符串，必须指定

rpartition(sep) -> (head,sep,tail)

：如果没有找到分隔符，就返回两个空元素和尾的三元组

字符串大小写

upper()

   全大写

lower()

   全小写

大小写做判断时候用

swapcase

   交换大小写

字符串排版

title() -> str

   标题的每个单词都大写

capitalize() -> str

   首个单词大写

center（width[,fillchar]）->

width 打印宽度

fillchar 填充的字符

zfill(width) -> str

    width 打印宽度，居右左边用0填充

ljust(width[,fillchar]) -> str

rjust(width[,fillchar]) -> str

字符串的修改

replace（old,new[,count]) ->str

  1.字符串中找到匹配替换为新字符串，返回新字符串
  2. count表示替换几次，不指定就是全部替换

字符串的修改

strip（[chars]）->str

  1.从字符串两短去除指定的字符集chars中的所有字符
  2.如果chars没有指定，去除两端的空白字符

lstrip([chars]) -> str

  从左开始

rstrip([chars]) -> str

  从右开始

字符串查找

   1.find(sub[,start[,end]]) -> int
   在指定区间[start,end),从左至右查找子串sub。找到返回正索引，没找到返回-1
   1.rfind(sub[,start[,end]]) -> int
   在指定区间[start,end),从左至右查找子串sub。找到返回正索引，没找到返回-1

字符串格式化

   1.字符串格式化是是一种拼接该字符串输出样式的手段，更灵活方便
      （1）join拼接只能使用分隔符，且要求被拼接的是可迭代对象且其元素是字符串
      （2）+ 拼接字符串还算方便，但是非字符串需要转换为字符串才能拼接

占位符：使用%和格式字符组成，例如%s、%d等

    s调用str(),r会调用repr()。所有兑现个都可以背这两个转换
    1.占位符中还可以插入修饰字符，例如%03d表示打印三个位置，不够前面补零
    2.format % values，格式字符串和被格式的值之间使用 % 分隔
    3.values 只能是一个对象，或是一个与格式字符串占位符数目相等的元组，或一个字典

format 函数格式字符串语法

     “{} {xxx}”.format(*args,**kwargs) ->str
     1.args 是一个可变位置参数，是一个元组
     2.kwargs 是可变关键字参数，是一个字典
     3.花括号表示占位符
     4.{}表示按照顺序匹配位置参数，（n）表示取位置参数为N的值
     5.{xxx}表示在关键字参数中搜索名称一致的
     6.{{}}表示打印花括号
  （1）位置参数
  "{}:{}".format('192.168.1.100'.8888),这就是按照位置顺序用位置参数替换前面的
  格式字符串的占位符中的内容
  （2）关键字参数或者命名参数
  "{server}{1}:{0}".format(8888.'192.168.1.100',server='Web Server info:'),
  位置参数按照序号匹配，关键字参数按照名词匹配
  （3）访问元素
  "{0[0]}.{0[1]}".format(('magedu'.'com'))
   (4) 对象属性访问
   from colletions import namedtuple
   Point = namedtuple('Point','x y')
   p=Point(4,5)
   "{{{0.x},{0.y}}}".format(p)
    (5)  对齐
    '{}*{}={2:<2}'.format(3,2,2*3)
    '{}*{}={2:<02>}'.format(3,2,2*3)
    '{}*{}={2:>02}'.format(3,2,2*3)
    '{:*^30}'.format('centered')
    '{:^30}'.format('centered')
    (6)进制
    "int{0:d};hex:{0:x};otc:{0:o};bin:{0:b}".format(42)
    "int{0:d};hex:{0:#x};otc:{0:#o};bin:{0:#b}".format(42)
    octtets = [192.168.0.1]
    '{:02x}{:02x}{:02x}{:02x}'.format(*octets)
    (7) 浮点数，宽度会撑破