创新路
我们一直在努力

Python入门系列(3):内置数据结构

序(ji)言(tang)部分

1.jpg

“年年岁岁花香似,岁岁年年人不同,不直人面何处去,桃花依旧笑春风”《代悲白头翁》—— 唐代 刘希夷

  新的2017年“已经”来临,即将面临又一轮的新春、夏、秋、冬。因为春天的播种,迎来了秋天的收获。“种瓜得瓜,种豆得豆”,就付出和收获这个概念上面,上天如同给与大家的时间一样的公平。生活之道“春捂秋冻夏凉冬藏”这句短短的养生语句,言简意核却又耐人寻味。新的一年开始,大家是否已经再自己的路上有了新的起点和新的目标呢?

  begin with the end in mind(以终为始),这个记得是位老师告诉我的一个心得,也可以说是一种心境吧。当自己浮躁、迷茫的时候,常常会想起它。当自己往往以为到达一个山的山峰的时候,本以为看到的是无尽美景画面,然后却看到自己仅仅只是站在一个群山当中的一个小小山峦。到达那个位置不是让我自己去否定自己做不到或者不可能。是让我认清一个现实,唯有不断前行、不断努力、才能找到那个真正想到的巅峰。唯有抱着把这个终点定位一个起步的勇气,才能有决心去寻找真正的目标。所谓"梦想"如同经典一样,不会因为时间的退却而消散。反而会因为时间的沉淀而越显珍贵。2017我来了!

课程拓扑图

1.jpg

线性结构和非线性结构

1.jpg

数据的逻辑结构分为线性结构、非线性解构

线性结构:是一个有序数据元素的集合。

常用的线性结构有:线性表,栈,队列,双队列,数组,串。


特征:

1.集合中必存在唯一的一个"第一个元素";

2.集合中必存在唯一的一个"最后的元素";

3.除最后元素之外,其它数据元素均有唯一的"后继";

4.除第一元素之外,其它数据元素均有唯一的"前驱"。

数据结构中线性结构指的是数据元素之间存在着“一对一”的线性关系的数据结构。

如(a0,a1,a2,…..,an),a0为第一个元素,an为最后一个元素,此集合即为一个线性结构的集合。

相对应于线性结构,非线性结构的逻辑特征是一个结点元素可能对应多个直接前驱和多个后继。

五种内置容器

列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dist)


列表

定义一个列表(也叫做初始化):

# 定义一个空列表
lst = [] 
lst2 = list()


 

追加(append)    L.append(object) -> None — append object to end

插入(insert)    L.insert(index, object) — insert object before index

扩展(extend)    L.extend(iterable) -> None — extend list by appending elements from the iterable

# 增加一个字串到列表中
lst.append('loki1')  
lst.insert(0,'loki2')  # Python中list的索引是从0开始
lst.append('loki3') 

In [27]: lst
Out[27]: ['loki2', 'loki1', 'loki3']

In [163]: l1
Out[163]: [1, 2, 3]

In [164]: l2
Out[164]: ['a', 'b', 'c']

In [165]: l1.extend(l2)    # 把l2列表加入到l1

In [166]: l1
Out[166]: [1, 2, 3, 'a', 'b', 'c']

In [169]: l1.extend([x for x in range(1,11)])    # 任何可迭代对象都可以扩展进去

In [170]: l1
Out[170]: [1, 2, 3, 'a', 'b', 'c', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

 

移除(remove)    L.remove(value) -> None — remove first occurrence of value.

删除并返回删除的值(pop)    L.pop([index]) -> item — remove and return item at index (default last).

清空列表(clear())    L.clear() -> None — remove all items from L (PS:Python2.x不具有,Python3.x才有))

# 删除一个列表元素
lst.remove('loki3')  # 指定删除元素内容
# 如果同时存在2个相同的内容,则会优先删除第一个发现的值
lst = ['loki2', 'loki1', 'loki3', 'loki3', 'loki4', 'loki3']
lst.remove('loki3') # 从左往右发现的第一个被移除
In [85]: lst
Out[85]: ['loki2', 'loki1', 'loki3', 'loki4', 'loki3']

In [86]: lst.pop()     # 默认从右往左删除
Out[86]: 'loki3'

In [87]: lst.pop()
Out[87]: 'loki4'

In [88]: lst
Out[88]: ['loki2', 'loki1', 'loki3'] 

In [92]: lst.pop(0)        # 也可以指定删除的索引
Out[92]: 'loki2' 

In [93]: lst
Out[93]: ['loki1', 'loki3']

In [129]: lst.clear()        # 清空列表里所有元素,注意后面有个()

In [130]: lst
Out[130]: []

也可以理解为下标操作

In [107]: lst
Out[107]: ['loki1', 'loki3']

In [108]: lst[0] = 'loki0' 

In [109]: lst[1] = 'loki110'

In [110]: lst
Out[110]: ['loki0', 'loki110']


 

统计(count)    L.count(value) -> integer — return number of occurrences of value

索引(index)    L.index(value, [start, [stop]]) -> integer — return first index of value.

In [117]: lst.index("loki0") # 查询当前元素对应的索引编号
Out[117]: 0

In [118]: lst.index("loki110") 
Out[118]: 1

In [125]: lst
Out[125]: ['loki0', 'loki110', 'loki', 'loki', 'loki', 'loki', 'loki']

In [126]: lst.count('loki') # 统计当前元素的数量,可以指定从第几个元素开始(结束)
Out[126]: 5

In [201]: lst
Out[201]: [1, 2, 3, 3, 4, 5]

In [202]: lst.reverse()        # 反转结果

In [203]: lst
Out[203]: [5, 4, 3, 3, 2, 1]

In [204]: lst.reverse()        # 再次反转结果,变回原值

In [205]: lst
Out[205]: [1, 2, 3, 3, 4, 5]

其他

排序 (sort) L.sort(key=None, reverse=False) -> None — stable sort *IN PLACE*

反转 (reverse) L.reverse() — reverse *IN PLACE* (PS:带*IN PLACE* 将直接覆盖原值内容)

反馈长度 (len())Return the number of items in a container.

身份识别 (id())Return the identity of an object.(CPython uses the object's memory address.)

"深"复制 (copy) L.copy() -> list — a shallow copy of L(Python2.x不具有,Python3.x才有)

In [193]: lst
Out[193]: [1, 3, 4, 2, 3, 5]

In [194]: lst.sort()

In [195]: lst
Out[195]: [1, 2, 3, 3, 4, 5]

In [196]: lst.sort(reverse=True)    # 把默认的升序改为降序

In [197]: lst
Out[197]: [5, 4, 3, 3, 2, 1]

In [212]: lst
Out[212]: [1, 2, 3, 3, 4, 5]

In [213]: len(lst)        # 反馈里面有6个元素
Out[213]: 6

In [214]: id(lst)        # 反馈当前lst变量再内存中的地址
Out[214]: 140055600262664

In [215]: lst
Out[215]: [1, 2, 3, 3, 4, 5]

In [216]: lst2 = lst.copy()        # 使用复制功能,把lst的内容复制给lst2并生成一个新的变量

In [217]: lst2
Out[217]: [1, 2, 3, 3, 4, 5]

In [218]: lst
Out[218]: [1, 2, 3, 3, 4, 5]

In [219]: lst2.append('loki')

In [220]: lst
Out[220]: [1, 2, 3, 3, 4, 5]

In [221]: lst2
Out[221]: [1, 2, 3, 3, 4, 5, 'loki']

In [229]: lst3 = lst.copy()

In [230]: id(lst)        # 通过查看内存地址发现,虽然元素一样。但是内存地址发生了变化
Out[230]: 140055600262664

In [231]: id(lst3)
Out[231]: 140055599797960

In [232]: lst
Out[232]: [1, 2, 3, 3, 4, 5]

In [233]: lst3
Out[233]: [1, 2, 3, 3, 4, 5]

元组

定义一个元组(也叫做初始化):

# 定义一个空元组
In [134]: t1 = tuple() 

In [135]: t2 = ()

# 注意一种错误的定义方法
In [138]: t3 = (1)

In [139]: t3
Out[139]: 1

In [140]: type(t3)     # 此时定义的是整形,而非元组
Out[140]: int

In [141]: t3 = (1,)   # 只有一个元素的元组,需要以","结尾

In [142]: type(t3)
Out[142]: tuple

 

统计(count)    L.count(value) -> integer — return number of occurrences of value

索引(index)    L.index(value, [start, [stop]]) -> integer — return first index of value.

In [143]: t1 = (1,2,3,4,5,6,7,7,8,8,9,9,0)

In [144]: t1
Out[144]: (1, 2, 3, 4, 5, 6, 7, 7, 8, 8, 9, 9, 0)

In [145]: t1.count(0)
Out[145]: 1

In [146]: t1.count(9)    # 统计t1里面"9"出现过的次数
Out[146]: 2

In [148]: t1.index(1)    # 查找元素"1"所在的索引位置
Out[148]: 0

切片操作 

[start:end:step]

In [235]: lst
Out[235]: [1, 2, 3, 3, 4, 5]

In [236]: lst[0]    # 索引0的元素
Out[236]: 1

In [237]: lst[:1]    # 从开始到索引1前面的元素
Out[237]: [1]

In [238]: lst[:2]    # 从开始到索引2前面的元素
Out[238]: [1, 2]

In [239]: lst[:5]    # 从开始到索引5前面的元素
Out[239]: [1, 2, 3, 3, 4]

In [240]: lst[:-1]  # 从开始到索引结尾的元素
Out[240]: [1, 2, 3, 3, 4]

In [241]: lst[-1]    # 结尾的元素
Out[241]: 5

In [242]: lst[::-1]    # 反转列表元素
Out[242]: [5, 4, 3, 3, 2, 1]

In [243]: lst
Out[243]: [1, 2, 3, 3, 4, 5]

In [244]: lst2 = lst[:]    # 类似‘深’复制

In [245]: lst2
Out[245]: [1, 2, 3, 3, 4, 5]

In [246]: lst2.append('loki')

In [247]: lst
Out[247]: [1, 2, 3, 3, 4, 5]

In [248]: lst2
Out[248]: [1, 2, 3, 3, 4, 5, 'loki']

In [252]: lst = list(range(10)) # 使用range函数生成一个0~9的数组

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

In [254]: lst[2:5]    # 显示从第二个索引到第5个之前的元素
Out[254]: [2, 3, 4]

In [255]: lst[2:5:2]    # 显示从第二个索引到第5个之前的元素,步长为2
Out[255]: [2, 4]

In [256]: lst[5:2:-1]    # 显示从索引5往前到索引2之前的元素,步长为-1
Out[256]: [5, 4, 3]

In [257]: lst[5:2]    # 当step 为负数的时候,从后往前数,此事start应该大于end,否则会返回空列表
Out[257]: []

In [260]: lst[::2]        # 获取偶数
Out[260]: [0, 2, 4, 6, 8]

In [261]: lst[1::2]    # 获取奇数
Out[261]: [1, 3, 5, 7, 9]

In [262]: lst[1::2][::-1]    # 相当于进行2次切片
Out[262]: [9, 7, 5, 3, 1]

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

In [269]: lst[3:5]
Out[269]: [3, 4]

In [270]: lst[3:5] = [100,110]        # 把索引3~5的内容修改为[100,110],数量可以不匹配

In [271]: lst
Out[271]: [0, 1, 2, 100, 110, 5, 6, 7, 8, 9]

解包/封包

解包把集合里的元素赋值给变量,封包是把变量构建元组。

In [280]: l1 = ['loki','16','IT','x@x.com']

In [281]: name,age,job,mail = l1    # 解包,把列表l1的值分别赋值给4个字段

In [282]: name
Out[282]: 'loki'

In [283]: age
Out[283]: '16'

In [284]: job
Out[284]: 'IT'

In [285]: mail
Out[285]: 'x@x.com'

In [286]: name,_,_,mail = l1    # 解包,其中只想要name字段和mail字段

In [287]: name,*_ = l1        # 解包,仅想要name字段,其他丢弃

In [288]: Allvalues = 'a','b','c'     # 封包

In [289]: type(Allvalues)
Out[289]: tuple

In [290]: Allvalues
Out[290]: ('a', 'b', 'c')

In [293]: Allnum = list(range(0,100)) # 创造0-99 个数值序列

In [294]: *_,endNum = Allnum    # 解包,仅需要最后的值

In [295]: endNum
Out[295]: 99

In [297]: lst
Out[297]: [1, [2, 3], 4]

In [298]: a,(b,c),d = lst    #解包含有嵌套的结构,需要对应格式

成员运算符

in 

not in

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

In [264]: 3 in lst        # 3 是否存在这个列表内
Out[264]: True

In [265]: 10 in lst        # 10 是否存在这个列表内
Out[265]: False

In [266]: 10 not in lst    # 10 不存在这个列表内
Out[266]: True

In [267]: 3 not in lst     # 3 不存在这个列表内
Out[267]: False

字符串

字符串是不可变的

定义字符串:

In [149]: s1 = 'loki1'    # 可以使用单引号

In [150]: s2 = "loki2"    # 也可以使用双引号

In [156]: s3 = '''Who     # 还能使用三引号(单双都可以用于,需要换行情况下)
   .....: am
   .....: i'''

In [151]: type(s1)
Out[151]: str

In [152]: type(s2)
Out[152]: str

连接 

使用字符串连接列表内容(join) S.join(iterable) -> str

In [11]: l2
Out[11]: ['a', 'b', 'c']

In [12]: ":".join(l2)           # 用冒号把一个列表连接起来
Out[12]: 'a:b:c'

In [13]: ",".join(l2)             # 用逗号把一个列表连接起来
Out[13]: 'a,b,c'

In [14]: "".join(l2)             # 去掉列表里面间隔,合并一个整的字符串
Out[14]: 'abc'

分割 

(split)    S.split(sep=None, maxsplit=-1) -> list of strings

左分隔(lstrip)    S.lstrip([chars]) -> str

右分割(rsplit)    S.rstrip([chars]) -> str

行分隔(splitlines)    S.splitlines([keepends]) -> list of strings

3元组分割(partition)    S.partition(sep) -> (head, sep, tail)

3元组分割[从右往左](rpartition)    S.partition(sep) -> (head, sep, tail)

In [21]: s3
Out[21]: 'loki,zhangsan,li4'

In [22]: l1 = s3.split(',')        # 把逗号定位成分隔符,进行分隔转化为列表

In [23]: l1
Out[23]: ['loki', 'zhangsan', 'li4']

In [40]: s1 = '!00123400#'

In [41]: s1.lstrip("!")         # 针对字串左边(left)进行分隔
Out[41]: '00123400#'

In [42]: s1.rstrip("#")         # 针对字串右边(right)进行分隔
Out[42]: '!00123400'

In [57]: s1
Out[57]: " How are You?\nWhat's you name?\nAre you ok?"

In [58]: s1.splitlines()        # 针对换行符进行分隔
Out[58]: [' How are You?', "What's you name?", 'Are you ok?']

In [74]: s1
Out[74]: 'http://www.cdbaidu.com'

In [75]: s1.partition('://')
# 返回一个3元的元组,第一个为分隔符左边的子串,第二个为分隔符本身,第三个为分隔符右边的子串。(默认从左往右)
Out[75]: ('http', '://', 'www.cdbaidu.com')

In [78]: s2
Out[78]: 'baidu.com/index.html'

In [79]: s2.rpartition('/')    # 从右边往左边进行分隔
Out[79]: ('baidu.com', '/', 'index.html')

修改  

转换所有单词首字母大写(title) 

转换大写字母(upper) 

转换小写字母(lower) 

首字母大写(capitalize)

字符串居中(center)

左对齐(ljust)

右对齐(rjust)

“零”填充(zfill)

In [33]: s1 = 'loki1'

In [34]: id(s1)            # 字符串内容不存在修改一说,通过id()函数看到内存的地址是
Out[34]: 140055600125128

In [35]: s1 = 'loki2'      # 并非修改,而是重新生成了一个变量s1

In [36]: id(s1)            
Out[36]: 140055600124400

In [80]: s1 = 'abc def ghi'        

In [81]: s1.title()            # 单词首字母大写
Out[81]: 'Abc Def Ghi'

In [82]: s1.upper()        # 所有字母变成大写
Out[82]: 'ABC DEF GHI'

In [83]: s2 = s1.upper()

In [84]: s2
Out[84]: 'ABC DEF GHI'

In [85]: s2.lower()        # 所有字母变成小写
Out[85]: 'abc def ghi'

In [86]: s2.capitalize()        # 仅首个字母大写
Out[86]: 'Abc def ghi'

In [307]: s1.center(80)        # 这里的80代表宽度
Out[307]: '                                      loki                                      ' # 居中后效果

In [308]: s1.center(80,'#')        # 为了让居中更明显,空白部分使用‘#’填充
Out[308]: '######################################loki######################################'

In [309]: s1.ljust(80)
Out[309]: 'loki                                                                            ' # 居左对齐效果

In [310]: s1.ljust(80,'#')        # 为了让居左更明显,空白部分使用‘#’填充
Out[310]: 'loki############################################################################'

In [311]: s1.rjust(80)
Out[311]: '                                                                            loki'# 居右对齐效果

In [312]: s1.rjust(80,'#')        # 为了让居左更明显,空白部分使用‘#’填充
Out[312]: '############################################################################loki'

In [317]: s1.zfill(80)            # '零填充'效果
Out[317]: '0000000000000000000000000000000000000000000000000000000000000000000000000000loki'

判断 

# 判断是否全是字母和数字 S.isalnum()
In [326]: s1 = 'loki'

In [327]: s1.isalnum()
Out[327]: True

In [328]: s1 = s1+'123'

In [329]: s1.isalnum()
Out[329]: True

In [330]: s1 = s1+'.,*'

In [331]: s1.isalnum()
Out[331]: False

In [332]: s1
Out[332]: 'loki123.,*'

# 判断是否全是字母S.isalpha()
In [333]: s1 = 'loki'

In [334]: s1.isalpha()
Out[334]: True

In [335]: s1 = s1+'123'

In [336]: s1.isalpha()
Out[336]: False

In [337]: s1
Out[337]: 'loki123'

# 判断是否全是空格S.isspace() 

In [345]: s1 = 'loki '

In [346]: s1.isspace()
Out[346]: False

In [347]: s1 = ''

In [348]: s1.isspace()
Out[348]: False

In [349]: s1 = ' '

In [350]: s1.isspace()
Out[350]: True

In [351]: s1 = '             '

In [352]: s1.isspace()
Out[352]: True

# 判断是否所有单词首字母是否大写S.istitle() 
In [353]: s1 = 'loki'

In [354]: s1.istitle()
Out[354]: False

In [355]: s1.title()
Out[355]: 'Loki'

In [356]: s1 = s1.title()

In [358]: s1.istitle()
Out[358]: True

In [359]: s1 = 'lokI'

In [360]: s1.istitle()
Out[360]: False

# 判断是否全是大写字母 S.isupper() 
In [361]: s1 = 'loki is Good man'

In [362]: s1.isupper()
Out[362]: False

In [363]: s1 = s1.upper()

In [364]: s1
Out[364]: 'LOKI IS GOOD MAN'

In [365]: s1.isupper()
Out[365]: True

In [366]: s1 = 'LOKI IS GOOD MAn'

In [367]: s1.isupper()
Out[367]: False

# 判断是否全是小写字母S.islower()
In [368]: s1
Out[368]: 'LOKI IS GOOD MAn'

In [369]: s1.islower()
Out[369]: False

In [370]: s1.lower()
Out[370]: 'loki is good man'

In [371]: s1 = s1.lower()

In [372]: s1.islower()
Out[372]: True

In [373]: s1 = 'loki is good maN'

In [374]: s1.islower()
Out[374]: False

# 判断前缀是否包含x字符 S.startswith('x')
In [376]: s1 = "# This's Comments"

In [377]: s1
Out[377]: "# This's Comments"

In [378]: s1.startswith('#')
Out[378]: True

In [379]: s2 = "This's Comments #"

In [380]: s2.startswith('#')
Out[380]: False

# 判断后缀是否包含x字符S.endswith('x')

In [383]: s3 = 'windows.exe'

In [384]: s3.endswith('.exe')
Out[384]: True

查找与替换

统计出现几次(count)

从左往右边寻找,找不到抛出-1(find)

从右边往左边统计(rfind)

从左往右边寻找,找不到抛出异常(index)

从右边往左边的索引号(rindx)

把查找到的值进行替换(replace(old, new[, count]))

In [385]: s1
Out[385]: "# This's Comments"

In [386]: s1.count('s')        # 统计出现了几次
Out[386]: 3

In [387]: s1.find('s')         # 从左往右找到的第一个的索引号
Out[387]: 5

In [388]: s1.find('#')
Out[388]: 0

In [389]: s1.find('!')        # 找不到的情况下反馈“-1”
Out[389]: -1

In [390]: s1.rfind('s')        # 从右往左找
Out[390]: 16

In [391]: s1.replace("This's", "I'm")        # 查找和替换
Out[391]: "# I'm Comments"

格式化

printf style  

主要解决:

  1. 反复出现

  2. 需要格式化的内容多

In [393]: ' i am %s' % ('loki')
Out[393]: ' i am loki'

In [394]: ' i am %(name)s,age is %(age)s' % {'name':'loki', 'age':'16'}
Out[394]: ' i am loki,age is 16'

In [396]: ' i am %s %s %s ' % ('Frist', 'second','thirD')
Out[396]: ' i am Frist second thirD '

In [397]: ' i am %s %s %s ' % ('thirD', 'Frist', 'second')
Out[397]: ' i am thirD Frist second '

这里除了%s还有很多,详见下面列表

'd' Signed integer decimal.
'i' Signed integer decimal.
'o' Signed octal value. (1)
'u' Obsolete type – it is identical to 'd'. (7)
'x' Signed hexadecimal (lowercase). (2)
'X' Signed hexadecimal (uppercase). (2)
'e' Floating point exponential format (lowercase). (3)
'E' Floating point exponential format (uppercase). (3)
'f' Floating point decimal format. (3)
'F' Floating point decimal format. (3)
'g' Floating point format. Uses lowercase exponential format if exponent is less than -4 or not less than precision, decimal format otherwise. (4)
'G' Floating point format. Uses uppercase exponential format if exponent is less than -4 or not less than precision, decimal format otherwise. (4)
'c' Single character (accepts integer or single character string).
'r' String (converts any Python object using repr()). (5)
's' String (converts any Python object using str()). (5)
'a' String (converts any Python object using ascii()). (5)
'%' No argument is converted, results in a '%' character in the result.

'#' The value conversion will use the “alternate form” (where defined below).
'0' The conversion will be zero padded for numeric values.
'-' The converted value is left adjusted (overrides the '0' conversion if both are given).
' ' (a space) A blank should be left before a positive number (or empty string) produced by a signed conversion.
'+' A sign character ('+' or '-') will precede the conversion (overrides a “space” flag).

In [423]: '%f' % 0.00123        # 浮点数
Out[423]: '0.001230'

In [424]: '%0.3f' % 0.00123        # 浮点数保留小数点后面3位
Out[424]: '0.001'

 [436]: '%10.3f' % 123.5         # 浮点数,限制总长度10,保留小数点后面3位
Out[436]: '   123.500'

In [437]: '%09d' % 12345        # 整数,限制总长度9,不足9位补“0”
Out[437]: '000012345'

In [439]: '%-9d' % 12345        # 整数,限制总长度9,不足9位后面补空格
Out[439]: '12345    '

In [440]: '%+9d' % 12345        # 整数,限制总长度9,不足前面补空格,并且显示“+”符号
Out[440]: '   +12345'

format方法

 字符串格式化的另外一种方法

In [1]: ' i am {}'.format('loki')    # 标准格式
Out[1]: ' i am loki'

In [2]: ' i am {1}'.format('zhangsan','loki') # 带索引模式,仅调用其中一个
Out[2]: ' i am loki'

In [4]: ' i am {1}, my age is {0}'.format(30,'loki') # 带索引模式,调用2个,位置和顺序很重要
Out[4]: ' i am loki, my age is 30'

In [5]: ' i am {name}, my age is {age}'.format(age=16,name='loki') # 关键字模式
Out[5]: ' i am loki, my age is 16'

In [9]: 'My COM is {0}, i like {0}. Once {0} ,You got it!'.format('baidu') # 一个单词多次复用
Out[9]: 'My COM is baidu, i like baidu. Once baidu ,You got it!'

In [10]: class LO:                # 定义一个类,类是什么以后会具体说,这里仅做演示
   ....:     def __init__(self):
   ....:         self.x = 1
   ....:         self.y = 2
   ....:         self.z = 'loki'
   ....:         

In [11]: a = LO()                # 类的实例化

In [12]: a.x
Out[12]: 1

In [13]: a.y
Out[13]: 2

In [14]: a.z
Out[14]: 'loki'

In [15]: 'he name is {0.z}, he number is {0.x}{0.y}'.format(a) # 进行调用
Out[15]: 'he name is loki, he number is 12'

In [21]: '{0[0]}{0[1]}{1[0]}{1[1]}'.format('loooo','killll').capitalize() # 这样组合一下还认识么?
Out[21]: 'Loki'

In [36]: alphabet = [chr(i) for i in range(97,123)]        # 生成a-z的字母表

In [36]: '{0[22]}{0[22]}{0[22]}{1}{0[1]}{0[0]}{0[8]}'.format(alphabet,'.') # 有没有想起某个挂马脚本?
Out[36]: 'www.bai' 

In [41]: '{0!a}'.format("转码ASCII")
Out[41]: "'\\u8f6c\\u7801ASCII'"

In [42]: '{0:^80}'.format("居中对齐")
Out[42]: '                                      居中对齐                                      '

In [46]: '{0:>80}'.format("右对齐")
Out[46]: '                                                                             右对齐'

In [47]: '{0:<80}'.format("左对齐")
Out[47]: '左对齐                                                                             '


In [49]: '{0:#^30}'.format("左对齐")
   ....:     
Out[49]: '#############左对齐##############'

In [55]: '{0:{a}^{b}}'.format('feel',a='囧',b=10)      # 0定义feel,居中对齐使用字符'囧',字符宽度10
Out[55]: '囧囧囧feel囧囧囧'

扩展介绍:Python编码介绍

查看Python的默认编码方法:

import sys
sys.getdefaultencoding()

Python 2.x 默认编码:ascii

Python 3.x 默认编码:utf-8

ascii: 8字节,只有英文

unicode/GBK:定长16字节,中英文都是16字节

utf-8: 是可变的长度,英文用8字节,中文用24字节。

# Python 3.x
In [405]: s = '帅'

In [406]: s.encode('GBK')
Out[406]: b'\xcb\xa7'

In [407]: s.encode('UTF-8')
Out[407]: b'\xe5\xb8\x85'

# Python 2.x
In [12]: s = '马'

In [13]: s
Out[13]: '\xe9\xa9\xac'     # ascii


bytes

python3特有,python2里不区分bytes和str

bytes和str的区别在于bytes是byte的序列 而str是unicode的序列

In [56]: s1 = 'loki'

In [57]: type(s1)
Out[57]: str

In [58]: s2 = b'loki'        # 定义上非常简单,前面加个小写字母b

In [59]: type(s2)
Out[59]: bytes

In [61]: s1 = '四川成都'

In [62]: b1 = s1.encode()

In [63]: b1
Out[63]: b'\xe5\x9b\x9b\xe5\xb7\x9d\xe6\x88\x90\xe9\x83\xbd'

In [64]: for x in s1:print(x)        # 得到的是字符串
四
川
成
都

In [65]: for x in b1:print(x)        # 得到的是字节
229
155
155
229
183
157
230
136
144
233
131
189

# str使用encode方法转化为bytes,bytes通过decode转化为str

In [65]: b1 = s1.encode()

In [66]: b1
Out[66]: b'\xe5\x9b\x9b\xe5\xb7\x9d\xe6\x88\x90\xe9\x83\xbd'

In [67]: s1
Out[67]: '四川成都'

In [68]: b1.decode()
Out[68]: '四川成都'

f = open('/xx/xxx/gbk.txt','b')  # 以二进制方式读取非utf8文件 
buf = f.read() buf.decode('GBK') # 再用GBK进行解码

bytearray

In [69]: b1 = b'1234'

In [70]: b1[0]
Out[70]: 49

In [81]: type(b1)
Out[81]: bytes

In [80]: b1[0] = '99'             # 提示不支持修改,看来和str一样
TypeError: 'bytes' object does not support item assignment


In [83]: b2 = bytearray(b1)        # 把b1的值赋值给b2并转换类型为bytearray

In [84]: type(b2)
Out[84]: bytearray

In [88]: b2
Out[88]: bytearray(b'1234')        

In [89]: b2[0] = 54                 # 发现bytearray是可以进行修改,这里的54是数字“6”的16进制编码

In [90]: b2
Out[90]: bytearray(b'6234')

# 那么为什么数字“6”的16编码是54呢?

In [92]: int(b'6'.hex(),16)        # 16进制编码
Out[92]: 54

# 结论: bytearry是可变的 bytes是不可变的

# 那么把byte不可变,通过bytearray进行转换后修改可变
In [93]: b1 = b'1234'

In [94]: b2 = bytearray(b1)

In [95]: b2[0] = int(b'6'.hex(),16)

In [96]: b2
Out[96]: bytearray(b'6234')

In [97]: bytes(b2)
Out[97]: b'6234'

In [98]: b1 = bytes(b2)

In [99]: type(b1)
Out[99]: bytes

扩展介绍:进制转换

# 10进制转为2进制
bin(10)

# 2进制转为10进制
hex(10)

# 10进制转为16进制
hex(10)

# 10进制转为2进制
int("1001",2)

# 16进制到10进制
int('ff', 16)

# 10进制转为8进制
print("%o" % 10)

# 16进制到2进制
bin(0xa)

# 10进制到8进制
oct(8)

# 2进制到16进制
hex(0b1001)

小结

  断断续续用上班不太忙的零散时间把以前的python知识进行了一次巩固并分享对这个有兴趣的伙伴吧,对基础又有了一次重新的认识。如果各位看客老爷觉得有什么建议,就评论里给我留言吧。也欢迎大家来沟通python的相关问题。2017年希望这个系列能够坚持做完吧。:)

未经允许不得转载:天府数据港官方信息博客 » Python入门系列(3):内置数据结构

客官点个赞呗! (2)
分享到:

评论 抢沙发

评论前必须登录!

天府云博 - 做有态度的开发&运维&设计学习分享平台!

联系我们百度云主机