元组冒泡法及字符串处理

Thunk_Lee • • Python干货

tuple buble string

##元组冒泡法及字符串处理

元组tuple：
  • 不可变对象，有序的序列。
  • 使用（）表示
  • 空元组基本没用，因为不可变
  • 当元组只有一个元素时请用（1，）
In [15]: t=(1,)*5
In [16]: t
Out[16]: (1, 1, 1, 1, 1)
In [18]: id(t)
Out[18]: 275970285904
In [20]: t=t*5
In [21]: t
Out[21]: (1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
In [22]: id(t)
Out[22]: 275969422624#通过两个id的比较证明元组只能重新定义不可修改
In [23]: t=(range(1,7,2))#此处需要注意，（）不能正常显示range函数
In [24]: t
Out[24]: range(1, 7, 2)
In [25]: type(t)
Out[25]: range
In [26]: t=tuple(range(1,7,2))#这样可以正常显示想要显示的range函数
In [27]: t
Out[27]: (1, 3, 5)
元组的访问
  • 支持索引（下标）
  • 支持正负索引，索引不可以越界，否则引发异常indexerror
  • tuple[index],index就是索引，使用中括号访问。
元组查询
  • index(value,[start,[stop]])
    • 通过值value，从指定区间查找列表内的元素是否匹配
    • 匹配到第一个就立即返回索引
    • 匹配不到，抛出异常valueerror
In [31]: t
Out[31]: (1, 3, 5)
In [32]: t.index(3)
Out[32]: 1
In [33]: t.index(3,0,5)#注意end可以指定比最后一个索引大的数值。
Out[33]: 1
In [37]: t.index(4,0,5)
—————————————————————————
ValueError Traceback (most recent call last)
<ipython-input-37-d3ce7b01939a> in <module>()
—-> 1 t.index(4,0,5)
ValueError: tuple.index(x): x not in tuple##此处不是报valueerror，而是提示vlue not in tuple
  • count(value):返回列表中匹配value的次数
In [41]: t
Out[41]: (1, 3, 5)
In [42]: t.count(3)
Out[42]: 1
In [43]: t.count(4)
Out[43]: 0#匹配不到显示零，不会报错
  • 时间复杂度：index和count都是O(n)，随着元组元素的规模的增大，而效率下降。
  • len(tuple):返回元素的个数
  • 元组是只读的，所以增删改方法都没有。可以理解成权限更低的列表。
  • 元组节约内存，比列表
  • 目的：不让其他人改变元素，可当做只读列表
  • 引用类型可以变，相当于换了一件衣服：例如：t=(1,[2,3],4):此处23可以修改
命名元组namedtuple
  • 目的：如果tuple中的元素很多的时候操作起来就比较麻烦，有可能会由于索引错误导致出错。namedtuple对象就如它的名字说定义的那样，你可以给tuple命名。
  • namedtuple方法在collections方法集中，所以使用需要from collections import namedtuple
  • namedtuple(typename,field_names,verbose=False,rename=False)
    • 命名元组，返回一个元组的子类，并定义了字段
    • field_names可以是空格或逗号分割的字段的字符串，可以是字段的列表
In [50]: from collections import namedtuple
In [51]: Point=namedtuple(‘_Point’,[‘x’,’y’])
In [52]: p=Point(4,5)
In [53]: p.x+p.y
Out[53]: 9
In [55]: P=namedtuple(‘a’,[‘x’,’z’])#此处的a是field_names,必须是字符形式的非数字
In [56]: p
Out[56]: _Point(x=4, y=5)
In [57]: P
Out[57]: __main__.a
In [58]: c=P(4,5)
In [59]: cx
In [70]: d=namedtuple(1,[‘x’,’y’])#此处证明field_names不可以是数字，加上引号也不可以
—————————————————————————
NameError Traceback (most recent call last)
<ipython-input-59-c2e08fa19a2c> in <module>()
—-> 1 cx
NameError: name ‘cx’ is not defined#调用方法出错
In [60]: c.x
Out[60]: 4
In [67]: d=namedtuple(‘0’,[‘x’,’y’])
—————————————————————————
ValueError Traceback (most recent call last)
<ipython-input-67-5f18d65cc1d7> in <module>()
—-> 1 d=namedtuple(‘0’,[‘x’,’y’])
c:\users\devops\appdata\local\programs\python\python35\lib\collections\__init__.py in namedtuple(typename, field_names, verbose, rename)
401 if not name.isidentifier():
402 raise ValueError(‘Type names and field names must be valid ‘
–> 403 ‘identifiers: %r’ % name)
404 if _iskeyword(name):
405 raise ValueError(‘Type names and field names cannot be a ‘
ValueError: Type names and field names must be valid identifiers: ‘0’
[使用举例]
In [72]: Student=namedtuple(‘Student’,’name age’)
In [74]: tom=Student(‘Thunk’,29)#实例化对象
In [75]: tom.name#用名称调用value
Out[75]: ‘Thunk’
In [76]: tom.age
Out[76]: 29
练习：
  • 依次接受用户输入的3个数，排序后打印：
    • 转换int后，判断大小排序
    • 使用max函数
    • 使用列表的sort方法
    • 冒泡法
冒泡法
  • 属于交换排序
  • 两两比较大小，交换位置。如同水泡咕嘟咕嘟往上冒
  • 结果分为升序和降序排列
  • 升序：
    • n个数从左至右，编号从0开始到n-1，索引0和1的值比较，如果索引0大，则交换两者的位置，如果索引1大，则不交换。继续比较索引1和2的值，将大值放在右侧。直至n-2和n-1比较完，第一轮比较完成。第二轮从索引0比较到n-2，因为最右侧n-1的位置上已经是最大值了，依次类推，每轮都会减少最右侧的不参与比较，直至剩下最后两个数比较。
  • 时间复杂度为O(n²)
num_list=[[1,9,8,5,6,7,4,3,2],[1,2,3,4,5,6,7,8,9],[1,2,3,4,5,6,9,8]]
nums=num_list[2]
print(nums)
length=len(nums)
count_swap=0
count=0
for i in range(length):
flag=False#每次循环初始化标签
for j in range(length-i-1):
count += 1
if nums[j] > nums[j+1]:
tmp=nums[j]
nums[j]=nums[j+1]
nums[j+1]=tmp
flag=True#此处如果修改下面的if语句永远不会执行
count_swap += 1
if not flag:
break
print(nums,count_swap,count)
字符串
  • 一个个字符组成有序的序列，是字符的集合
  • 使用单引号，双引号，三引号引住的字符序列
  • 字符串是不可变对象
  • Python3开始，字符串就是Unicode类型
  • 使用r/R将字符串中的特殊字符原样输出
    举例：
In [1]: s3=”’this’s a “string””’
In [3]: s3
Out[3]: ‘this\’s a “string”‘#####################`为什么自动加转义符？？`
In [4]: s4=’hello \n magedu.com’
In [5]: s4
Out[5]: ‘hello \n magedu.com’
In [6]: s5=r’this \n Thunk lee’
In [7]: s5
Out[7]: ‘this \\n Thunk lee’
In [8]: print(s4)#此处证明在无r的情况下特殊字符具有特殊功效
hello
magedu.com
In [9]: print(s5)#在加有r的情况下，特殊字符串也是原样输出
this \n Thunk lee
In [10]: sql=”””select * from user where name=’tom'”””#三引号内可以使用单双引号
In [11]: print(sql)
select * from user where name=’tom’
字符串访问
  • 下标：字符串支持索引访问
  • 有序的字符集合，字符序列
  • 可迭代
字符串join连接
  • “指定分隔符”.join(iterable)，用来连接字符串，其他类型不可以。
  • 可迭代对象内部必须是简单类型，复杂类型无法执行
    举例：
In [50]: “@”.join(“abcdefg”)##使用方法小括号内必须是可迭代对象，分隔符无所谓
Out[50]: ‘a@b@c@d@e@f@g’
In [51]: lst=[‘1’,[‘3′,’4′],’8’]##复杂类型无法处理
In [52]: “#”.join(lst)
—————————————————————————
TypeError Traceback (most recent call last)
<ipython-input-52-fa3d037801ad> in <module>()
—-> 1 “#”.join(lst)
TypeError: sequence item 1: expected str instance, list found
In [53]: lst=[‘1′,’4′,’8’]##简单类型正常处理
In [54]: “#”.join(lst)
Out[54]: ‘1#4#8’
In [56]: print(“\n”.join(lst))#使用换行符作为分隔符
1
4
8
In [57]: print(“\””.join(lst))#双引号作为分隔符
1″4″8
##疑问？lst=[1,2,3,4]是否可以用join，结果如下
In [1]: lst = [1,2,3,4]
In [2]: “#”.join(lst)
—————————————————————————
TypeError Traceback (most recent call last)
<ipython-input-2-fa3d037801ad> in <module>()
—-> 1 “#”.join(lst)
TypeError: sequence item 0: expected str instance, int found
In [3]: lst1=[“1″,”abc”,”345″]
In [4]: “#”.join(lst1)
Out[4]: ‘1#abc#345’
字符串连接
  • +：将两个字符串连接在一起，返回一先得字符串
In [58]: a=”abcdefg”
In [59]: b=”hijklmn”
In [60]: a+b
Out[60]: ‘abcdefghijklmn’
字符串分割
  • 1.split：将字符串按照分隔符分割成若干字符串，并返回列表
    • split(sep=None,maxsplit=-1)
      • 从左至右
      • sep指定分割字符串，缺省的情况下空白字符串作为分隔符
      • maxsplit指定分割次数，-1表示遍历整个字符串
    • rsplit：从右向左
    • splitlines([keepends])
      • 按照行来切分字符串
      • keepends指的是是否保留行分隔符
      • 行分隔符包括\n,\r\n,\r等
##split举例：
In [63]: s1=”I’m \ta super student”
In [64]: s1.split(sep=”,”)#由于没有此符号所以无法分割，注意必须拿元素中有的元素来分割
Out[64]: [“I’m \ta super student”]
In [65]: s1.split()#默认空格分隔‘ ’+
Out[65]: [“I’m”, ‘a’, ‘super’, ‘student’]
In [66]: s1.split(‘s’)#指定用s字符分割
Out[66]: [“I’m \ta “, ‘uper ‘, ‘tudent’]
In [67]: s1.split(“super”)#指定super来分割
Out[67]: [“I’m \ta “, ‘ student’]
##rsplit举例：
In [69]: s1.rsplit(“\t”,maxsplit=2)
Out[69]: [“I’m “, ‘a super student’]
In [70]: s1.rsplit(“s”,maxsplit=1)#此例子可以用于取路径中的文件名
Out[70]: [“I’m \ta super “, ‘tudent’]
In [71]: s=”/etc/sysconfig/network-scripts/ifcf-ens33″
In [72]: s
Out[72]: ‘/etc/sysconfig/network-scripts/ifcf-ens33’
In [73]: s.rsplit(“/”,1)
Out[73]: [‘/etc/sysconfig/network-scripts’, ‘ifcf-ens33’]
In [74]: list(s.rsplit(“/”,1))[1]
Out[74]: ‘ifcf-ens33’
  • 2.partition：将字符串按照分隔符分割成两段，返回这两段和分割符的tuple
  • partition(seq)
    • 从左至右，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组；如果没有找到分隔符，就返回头、2个空元素的三元组
    • seq分割字符串，必须制定
  • rpartition(seq):从右至左，如果没找到分割符就返回两个空元素和尾的三元组
In [94]: s1.partition(“\n”)#此函数又叫一刀两段
Out[94]: (“i’m a super student.”, ‘\n’, “you’re a super teacher.”)
In [95]: s1.partition(“s”)
Out[95]: (“i’m a “, ‘s’, “uper student.\nyou’re a super teacher.”)
In [96]: s1.rpartition(“s”)#从右开始切
Out[96]: (“i’m a super student.\nyou’re a “, ‘s’, ‘uper teacher.’)
In [97]: s1.partition(“x”)#不存在的分隔符会用空元素补全
Out[97]: (“i’m a super student.\nyou’re a super teacher.”, ”, ”)
In [98]: s1.rpartition(“x”)
Out[98]: (”, ”, “i’m a super student.\nyou’re a super teacher.”)
In [99]: s1.rpartition(“”)#不指定分隔符则报错
—————————————————————————
ValueError Traceback (most recent call last)
<ipython-input-99-9151ec630fbe> in <module>()
—-> 1 s1.rpartition(“”)
ValueError: empty separator
字符串大小写
  • upper()全大写
  • lower()全小写
  • swapcase()互换大小写
In [106]: a.upper()#这些方法是字符串下的方法，所以需要用str.upper()来调用
Out[106]: ‘ABCDEF’
In [107]: a.lower()
Out[107]: ‘abcdef’
In [108]: a.swapcase
Out[108]: <function str.swapcase>
In [109]: a.swapcase()
Out[109]: ‘AbcDef’
字符串修改
  • replace(old,new[,count]):
    • 字符串中找到匹配替换为新字串，返回新字符串
    • count表示替换几次，不指定默认全部替换
In [113]: a=’asdlkfjiefjoefjjjjjj’
In [114]: a.replace(‘j’,’#’)
Out[114]: ‘asdlkf#ief#oef######’
In [115]: a.replace(‘j’,’#’,2)
Out[115]: ‘asdlkf#ief#oefjjjjjj’
  • strip([chars])
    • 从字符串两端去除制定的字符集chars中的所有字符默认两段开始，如果从某一端开始可能会影响结果
    • 如果没指定chars，默认去除端的空白字符
    • lstrip([chars]):从左开始
    • rstrip([chars]):从右开始
1.In [116]: s=’\r \n \t Hello Python \n \t’
2.In [117]: s
3.Out[117]: ‘\r \n \t Hello Python \n \t’
4.In [118]: s.strip()##默认去除空白字符
5.Out[118]: ‘Hello Python’
6.
7.In [119]: s1=”I am very very very sorry”
8.In [121]: s1.strip(“vy”)
9.Out[121]: ‘I am very very very sorr’
10.In [122]: s1
11.Out[122]: ‘I am very very very sorry’
12.In [123]: s1.strip(“v”)
13.Out[123]: ‘I am very very very sorry’
14.In [124]: s1.strip(“I”)
15.Out[124]: ‘ am very very very sorry’
16.In [125]: s1.strip(“Iry”)
17.Out[125]: ‘ am very very very so’#只要两端匹配到就删除
18.
19.#lstrip,rstrip举例：
20.In [127]: s=”I am very very very sorry “
21.In [128]: s.strip(“Iy “)#两端开始
22.Out[128]: ‘am very very very sorr’
23.In [129]: s.lstrip(‘Iy ‘)#左开始
24.Out[129]: ‘am very very very sorry ‘
25.In [130]: s.rstrip(‘Iy ‘)#右开始
26.Out[130]: ‘I am very very very sorr’
字符串查找
  • find(sub[,start[,end]]) –>int
    • 在指定区间内[start,end),从左到右查找子串sub。找到返回索引，没找到返回-1
    • rfind(sub[,start[,end]])：从右往左查
In [131]: a
Out[131]: ‘asdlkfjiefjoefjjjjjj’
In [134]: a.find(“j”,0,100)
Out[134]: 6
In [135]: a[6]
Out[135]: ‘j’
In [136]: a.rfind(“j”,0,100)#从右往左找到第一个sub返回index，区间可以为负索引
Out[136]: 19
In [137]: len(a)
Out[137]: 20
In [138]: a.rfind(“x”,0,100)#没找到元素返回-1
Out[138]: -1
  • index(sub[,start[,end]])—>int跟find区别：抛出异常与否.具体使用方法相同
    • 在指定区间内[start,end),从左到右，查找子串sub，找到返回索引，没找到抛出异常valueerror
    • rindex(sub[,start[,end]]),从右到左
In [138]: a.rfind(“x”,0,100)#返回-1
Out[138]: -1
In [139]: a.index(“x”,0,100)#抛出value异常
—————————————————————————
ValueError Traceback (most recent call last)
<ipython-input-139-88e7d48786fe> in <module>()
—-> 1 a.index(“x”,0,100)
ValueError: substring not found
字符串判断
  • endswith(suffix[,start[,end]])–>bool
    • 在指定区间[start,end),字符串是否是suffix结尾
  • startswith(prefix,[,start[,end]])–>bool
    • 在指定区间xxx,字符串是否已prefix结尾
In [183]: s
Out[183]: ‘I am very very very sorry’#string集合
In [184]: s.startswith(“very”)
Out[184]: False
In [185]: s.startswith(“very”,5)
Out[185]: True
In [186]: s.startswith(“very”,5,9)
Out[186]: True
In [187]: s.endswith(“very”,5,9)
Out[187]: True
In [188]: s.endswith(“sorry”,5)
Out[188]: True
In [189]: s.endswith(“sorry”,5,-1)#无法取到-1，因为是开区间
Out[189]: False
In [190]: s.endswith(“sorr”,5,-1)#去掉y可以证明-1导致的false
Out[190]: True
In [191]: s.endswith(“sorry”,5,100)
Out[191]: True
字符串判断is系列
  • isalnum()–>bool是否是字母和数字组成
  • isalpha()：是否是字母
  • isdecimal()是否只包含十进制数字
  • isdigit()是否全部数字（0-9）
  • isidentifier()是不是字母和下划线开头，其他都是字母数字，下划线
  • islower()是否都是小写
  • isupper()是否都是大写
  • isspace()是否只包含空白字符
In [197]: s=”5″
In [198]: s.isdigit()
Out[198]: True#返回布尔值
In [199]: if s.isdigit():#字符串集合才可以使用
…: print(“Is number”)
Is number
字符串格式化
  • 字符串的格式化是一种拼接字符串输出样式的手段，更方便灵活
    • join拼接只能使用分隔符，且要求被拼接的是可迭代对象
    • +拼接字符串还算方便，但是非字符串需要先转换成字符串才能拼接
  • format函数格式字符串语法
    • “{} {xxx}”.format(*args,**kwargs)–>str
    • args是位置参数，是一个元组
    • kwargs是关键字参数，是一个字典
    • 花括号表示占位符
    • {}表示按照顺序匹配位置参数，{n}表示取位置参数索引为n的值
    • {xxxx}表示在关键字参数中搜索名称一致的
    • {{}}表示打印花括号
##用法举例：
#位置参数：
In [216]: “{}:{}”.format(‘192.168.0.1’,9999)
Out[216]: ‘192.168.0.1:9999’
#关键参数：
In [218]: “{server}:{}:{}”.format(“192.168.0.1″,8888,server=”app”)
Out[218]: ‘app:192.168.0.1:8888’
#访问元素：
In [223]: “{0[0]},{1[1]}”.format(“magedu”,”com”)
Out[223]: ‘m,o’
In [224]: “{0[0]},{1[2]}”.format(“magedu”,”com”)
Out[224]: ‘m,m’
In [225]: “{0},{1}”.format(“magedu”,”com”)
Out[225]: ‘magedu,com’
#对象属性访问
In [226]: from collections import namedtuple
In [227]: P=namedtuple(“P”,”x y”)
In [228]: p=P(4,5)
In [232]: “{}{}”.format(p.x,p.y)
Out[232]: ’45’
In [233]: “{0.x}{0.y}”.format(p)
Out[233]: ’45’
  • 对齐：
In [234]: ‘{0}*{1}={2:<2}’.format(2,3,2*3)#左对齐
Out[234]: ‘2*3=6 ‘
In [235]: ‘{0}*{1}={2:<02}’.format(2,3,2*3)
Out[235]: ‘2*3=60’
In [236]: ‘{0}*{1}={2:<02}’.format(2,3,2*3)
Out[236]: ‘2*3=60’
In [237]: ‘{0}*{1}={2:>02}’.format(2,3,2*3)
Out[237]: ‘2*3=06’
In [238]: ‘{:^30}’.format(“centered”)
Out[238]: ‘ centered ‘
In [239]: ‘{:*^30}’.format(“centered”)
Out[239]: ‘***********centered***********’
  • 进制：
In [240]: “int:{0:d}; hex:{0:x};oct:{0:n};bin:{0:b}”.format(43)
Out[240]: ‘int:43; hex:2b;oct:43;bin:101011’
In [241]: “int:{0:d}; hex:{0:#x};oct:{0:#n};bin:{0:#b}”.format(43)
Out[241]: ‘int:43; hex:0x2b;oct:43;bin:0b101011’
In [242]: octets=[192,168,0,1]
In [243]: ‘{:02X}{:02X}{:02X}{:02X}’.format(*octets)
Out[243]: ‘C0A80001’

本文来自投稿，不代表Linux运维部落立场，如若转载，请注明出处：http://www.178linux.com/87485

赞 (0)
Thunk_LeeThunk_Lee
0
上一篇 2017-09-23 15:11
下一篇 2017-09-23

相关推荐

电话咨询
在线咨询