python3序列详解

Python学习

一.字符串操作详解

1.字符串正向搜索： 最左侧第一个下标（偏移量）是0；
   反向搜索：最右侧第一个字符，偏移量是（-1）
2.replace()： 字符串的替换

>>> a = "adasdasd"
>>> b = a.replace('a','e')
>>> b
'edesdesd'
>>> a
'adasdasd'

Tip： 替换并不是在原有的字符串上直接进行修改的，而是替换之后生成了一个新的字符串
3.字符串切片 slice 操作：

a = “abcdefg”;
a[起始偏移量start：终止偏移量end：步长step]
a[1,5,1] = ‘bcde’ //不能到五，左闭右开
a[1,5,2] = ‘bd’ //每隔一个取一个

>>> a = "adasdasdasd"
>>> a[-3:]
'asd'
>>> a[-8:-3]
'sdasd'
>>> a
'adasdasdasd'
>>> a[::-1]
'dsadsadsada'

例题：
①将”to be or not to be”字符串倒序输出

>>> a = "to be or not to be"
>>> a[::-1]
'eb ot ton ro eb ot'

②将”sxtsxtsxtsxtsxt”字符串中所有的s和t输出

>>> b = "sxtsxtsxtsxtsxt"
>>> b[::-3]
'ttttt'
>>> b[::3]
'sssss'

4.split（）分割和join（）合并:
split(): 可以基于指定分隔符将字符串分隔成多个子字符串(存储到列表中)。如果不指定分隔符，则默认使用空白字符(换行符/空格/制表符)。示例代码如下:

>>> a = "to be or not to be"
>>> a.split()
['to', 'be', 'or', 'not', 'to', 'be']
>>> a.split('be')
['to ', ' or not to ', '']

join(): 作用是和split()方法的作用相反，实例：

>>> a = ['et','asa','sasa']
>>> '*'.join(a)
'et*asa*sasa'

join()和拼接符’+'效率的差距：

字符串驻留机制：仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串驻留池中。Python支持字符串驻留机制，对于符合标识符规则的字符串（仅包含下划线(_)、字母和数字）会启用字符串驻留机制驻留机制。

>>> a = "adb_33"
>>> b = "adb_33"
>>> a is b
True
>>> c = "dd#"
>>> d = "dd#"
>>> c is d
False

字符串比较：

a = “abc”;
“b” in a --> true
“d” not in a-->true

字符格式：从某方向以某格式以某字符补齐

>>> #使用ceneter()、ljust()、rjust()这三个函数用于对字符创实现排版。实例如下()
>>> a.center(10,"*")
'***SXT****'
>>> a.center(10)
'   SXT    '
>>> a.ljust(10,"*")
'SXT*******'
>>> a.rjust(10,"*")
'*******SXT'

字符查找方法：

len()： 返回字符串的长度
startswith(): 以指定的字符串开头
endswith(0: 以指定的字符串结尾
find(): 第一次出现指定字符串的位置
rfind(): 最后一次出现字符串的位置
count(): 指定字符串出现了几次
isalnum(): 所有的字符全是数字或者是字母

>>> a = "sfjkllahjhjfkl"
>>> len(a)
14
>>> a.startswith("sf")
True
>>> a.endswith("kl")
True
>>> a.find('a')
6
>>> a.rfind('l')
13
>>> a.isalnum()
True
>>> a.count('l')
3

大小写转换

capitalize(): 产生新的字符串,首字母大写
title(): 产生新的字符串，每个单词都首字母大写
upper(): 产生新的字符串，所有的字符串全都转换成大写
lower(): 产生新的字符串，所有的字符串转成小写
swapcase(): 产生新的字符串，左右的字母大小写颠倒

>>> b = "das dass dddd"
>>> b.capitalize()
'Das dass dddd'
>>> b.title()
'Das Dass Dddd'
>>> b.upper()
'DAS DASS DDDD'
>>> b.lower()
'das dass dddd'
>>> c = "adsAAAb"
>>> d = c.swapcase()
>>> d
'ADSaaaB'
>>> c
'adsAAAb'

format() 基本用法
（Python2.6开始）基本语法： 通过{} 和：来代替以前的%，实例：

>>> a = "名字是：{0}，年龄是{1}"
>>> a.format('da',3)
'名字是：da，年龄是3'

填充和补齐：
填充和补齐常常一起使用
^、<、>分别是居中、左对齐、右对齐 后面带宽度
： 号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充

>>> a = "{:*>8}"
>>> a.format("13")
'******13'

可变字符串
在Python中字符串属于不可变的对象，不支持原地修改，如果需要修改其中的值。只能创建新的字符串对象，但是我们确实需要经常原地修改字符串，可以使用io.StringIO对象或者使用array模块，示例：

>>> import io
>>> s = "hello.sxt"
>>> sio = io.StringIO(s)
>>> sio
<_io.StringIO object at 0x000001A70E7D0A60>
>>> sio.getvalue()
'hello.sxt'
>>> sio.seek(7)
7
>>> sio.write('a')
1
>>> sio.getvalue()
'hello.sat'

其他的方法：

isalnum() ： 是否为字母或者数字
isalpha(): 检测字符是否只有字母组成（含汉字）
isdigit()： 检测字符是否只有数字组成
isspace(): 检测字符是否为空白符
issuper(): 是否为大写的字母
islower(): 是否为小写的字母

二.关系运算符和运算操作

关系运算符可以连用：
C++： a>=2&&a<=5
Python: 2<=a<=5

Tip：
①Python中不支持自增自减
②位运算和算术操作>比较运算符>赋值运算符
③在复杂的运算中要用小括号组织

三.其他序列：

3.1列表

列表是内置的可变序列，是包含多个元素的有序连续的内存空间。列表中的元素可以使任意的类型的。

列表的创建：
基本创建：a = []      #创建一个空的列表对象
list() 创建：
>>>a = list()
>>>a
[]
>>>a = list(range(10))
>>>a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>a = list(‘s’)
>>>a
[‘a’]

Tip: range() ： 创造的不是一个列表，是一个class<range>,若要转换成list，请看下面的示例：

>>> a = range(0,10)
>>> list(a)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b = list(a)
>>> b
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a
range(0, 10)

以下是列表的常用方法：

insert(): 插入元素 但是在有大量元素时不建议使用，因为这样子会让这个位置后面的所有元素往后移动
append(): 增加元素 参数是普通元素
extend(): 增加元素 参数是列表
insert(index,x)： 增加元素 在index位置添加元素x
remove(x): 删除首次出现的元素
pop(x)： 删除并返回列表中指定为x的元素，默认是删除最后一个元素
clear(): 删除所有的元素

>>> a = [12,13,'a',42]
>>> b = ['1']
>>> a.append('ad')
>>> a
[12, 13, 'a', 42, 'ad']
>>> a.extend(b)
>>> a
[12, 13, 'a', 42, 'ad', '1']
>>> a.insert(2,'as')
>>> a
[12, 13, 'as', 'a', 42, 'ad', '1']
>>> a.remove(12)
>>> a
[13, 'as', 'a', 42, 'ad', '1']
>>> c = a.pop()
>>> a
[13, 'as', 'a', 42, 'ad']
>>> c
'1'
>>> a.clear()
>>> a
[]

以下是其他的方法：

reverse(): 翻转列表
sort(): 所有的元素原地排序
copy(): 返回列表对象的浅拷贝
del()：删除指定位置的元素
index(): 获取指定元素在列表中首次出现的索引
count()： 获得元素在列表中的出现次数
len()： 返回列表长度
max(): 返回列表中元素的最大值
min(): 返回列表中元素的最小值
sum(): 对数值型的列表进行求和操作，其他类型会报错

>>> a = [1,2,2]
>>> a.insert(1,2)
>>> a
[1, 2, 2, 2]
>>> a = [123,131,3211,11]
>>> a.sort()
>>> a
[11, 123, 131, 3211]
>>> a.reverse()
>>> a
[3211, 131, 123, 11]
>>> a.copy()
[3211, 131, 123, 11]
>>> b = a.copy()
>>> b
[3211, 131, 123, 11]

列表切片操作


Tip:贴片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错。起始偏移量小于0则会被当做0，终止偏移量大于“长度1”会被当成-1： 例如：

列表的排序

①不创建新的列表的排序 内置函数（sorted()）

>>> b = [1,23,133,0]
>>> b.sort()  #默认是升序排列
>>> b
[0, 1, 23, 133]
>>> b.sort(reverse = True)      #降序排列
>>> b
[133, 23, 1, 0]

②打乱顺序

>>> a = [12,222,1]
>>> import random
>>> random.shuffle(a)
>>> a
[222, 12, 1]

③创建新的列表的排序 内置函数（sorted）

>>> b = [1,22,33,0]
>>> sorted(b)
[0, 1, 22, 33]
>>> b
[1, 22, 33, 0]
>>> c = sorted(b)
>>> c
[0, 1, 22, 33]

④逆序排序
方式一.切片操作

>>> c = [321,43,4,0]
>>> c[::-1]
[0, 4, 43, 321]

方式二.迭代器

多维列表
一维列表可以帮助我们存储一维、线性的数据。
二维列表可以帮助我们存储二维、表的数据。例如下面的数据：

我们可以这样子来存储：

代码示例：

>>> a = [["甲",1223,'dadsda'],
["乙",12323,'dadqwdsda'],
["丙",122323,'dadsd312312a']]
>>> a
[['甲', 1223, 'dadsda'], ['乙', 12323, 'dadqwdsda'], ['丙', 122323, 'dadsd312312a']]

二维列表相当于是列表中的列表
二维列表中的元素我们可以通过索引的方式访问

>>> a[1][2]
'dadqwdsda'
>>> a[0][0]
'甲'
>>> a[1]
['乙', 12323, 'dadqwdsda']

内存结构：

3.2元组

元组属于不可变序列，不能修改元组中的元素。因此，元组中没有增删改的方法。

元组的访问和计数
索引访问：

>>> a = tuple([1,2,3,4243])
>>> a
(1, 2, 3, 4243)
>>> a[1]
2
>>> a[0]
1

切片访问:

>>> a = tuple([1,2,3,4243])
>>> a[1:3]
(2, 3)
>>> a[:4]
(1, 2, 3, 4243)
>>> a[:3]
(1, 2, 3)

元组的排序： （内置函数sorted） 生成的是一个列表对象

>>> a = tuple([1,23,3,0])
>>> b = sorted(a)
>>> b  #注意是生成的列表
[0, 1, 3, 23]
>>> c = tuple(sorted(a))
>>> c
(0, 1, 3, 23)

zip操作： 将多个列表对应位置的元素组合成元组，并返回这个zip对象

元组的生成器推导式

>>> s = (x*2 for x in range(5))   #生成了一个只能使用一次的生成器
>>> s
<generator object <genexpr> at 0x0000022A06C48D60>
>>> tuple(s)
(0, 2, 4, 6, 8)
>>> tuple(s)  #第二次使用为空 生成器的指针跳出
()

指针移动示例

>>> s = (x*2 for x in range(4))
>>> s.__next__()
0
>>> s.__next__()
2
>>> s.__next__()
4
>>> s.__next__()
6
>>> s.__next__()
Traceback (most recent call last):
  File "<pyshell#20>", line 1, in <module>
    s.__next__()
StopIteration

元组的总结：
①元组的核心特点是： 不可变序列
②元组的访问和处理速度比列表快
③与整数字符串一样，元组可以作为字典的键，列表则永远不能作为字典的关键字使用。

3.3字典

字典概述：字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含︰“键对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。

字典和列表: 列表中我们通过“下标数字”找到对应的对象。字典中通过“键对象”找到对应的“值对象”。“键”是任意的不可变数据，比如∶整数、浮点数、字符串、元组。但是∶列表、字典、集合这些可变对象，不能作为“键”。并且“键”不可重复。“值”可以是任意的数据，并且可以重复

字典的典型定义：

a = {'name':'yyy','age':12,'job':'student'}

字典的创建
①我们可以通过{}、dict()来创建字典对象

>>> a = {'name':'yyy','age':12,'job':'student'}
>>> b = dict(name = 'yyy',age = 13,job = 'student')
>>> c = dict([("name",'yyy'),('age',12)])
>>> d = {}  #空的字典对象
>>> e = dict()    #空的字典对象

②通过zip()创建字典对象

>>> k = ['name','age','job']   #键
>>> v = ['yyy',12,'teacher']   #值
>>> d = dict(zip(k,v))     #通过zip来包装
>>> d
{'name': 'yyy', 'age': 12, 'job': 'teacher'}

③通过fromkeys创建值为空的字典

>>> a = dict.fromkeys(['name','age','job'])
>>> a
{'name': None, 'age': None, 'job': None}   #这里的None是一个值，表示为空

字典元素的访问
①通过[键] 获得"值"。若值不存在，则抛出异常。

>>> a = {'name':'yyy','age':12,'job':'student'}
>>> a['name']
'yyy'

②通过get方法获得值。推荐使用，因为指定键不存在时，返回的是None；也可以设定指定键不存在时默认返回的对象。

>>> a.get('name')
'yyy'
>>> a.get('adda')
>>> print(a.get('adas'))
None
>>> a.get('sadasda','没')
'没'

③列出所有的键值对

>>> a.items()
dict_items([('name', 'yyy'), ('age', 12), ('job', 'student')])

④写出所有的键，列出所有的值

>>> a.keys()
dict_keys(['name', 'age', 'job'])
>>> a.values()
dict_values(['yyy', 12, 'student'])

⑤len() 键值对的个数

>>> len(a)
3

⑥检测一个"键"是否在字典中

>>> 'name' in a
True

字典元素的添加修改和删除
①给字典新增键值对，若键已经存在则覆盖旧的，若不存在则添加新的

>>> a['s'] = 123
>>> a
{'name': 'yyy', 'age': 12, 'job': 'student', 's': 123}

②使用update() 将字典中的所有键值对全部添加到旧字典对象上。如果key有重复，则直接覆盖

>>> a = {'name':'yyy','age':12,'job':'student'}
>>> b = {'name':'asa','age':1232,'money':12222}
>>> a.update(b)
>>> a
{'name': 'asa', 'age': 1232, 'job': 'student', 'money': 12222}

③字典元素的删除，可以使用del()方法；或者clear()删除多有的键值对；pop（）删除所有的键值对并返回指定的键值对对象。

④popitem(): 随机删除和返回该键值对。字典是“无序可变序列”，因此没有第一个元素、最后一个元素的概念;popitem 弹出随机的项，因为字典并没有"最后的元素"或者其他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效(因为不用首先获取键的列表）。

>>> a.popitem()
('money', 12222)
>>> a
{'name': 'asa', 'age': 1232, 'job': 'student'}
>>> a.popitem()
('job', 'student')
>>> a
{'name': 'asa', 'age': 1232}

序列解包

可以用于元组、列表、字典。方便我们对多个变量赋值。

>>> x,y,z = 20,10,30  #列表
>>> x
20
>>> a,b,c = (20,30,10)  #元组
>>> a
20

序列解包用于字典时，默认是对“键”进行操作﹔如果需要对键值对操作，则需要使用items0 ﹔如果需要对“值”进行操作，则需要使用values0 ;

>>> s = {'name ':'aaa','age':12,'class':12}
>>> x,y,z = s
>>> x
'name '
>>> a,b,c = s.values()
>>> a
'aaa'
>>> h,j,k = s.items()
>>> h
('name ', 'aaa')

表格数据使用字典和列表存储，并且实现访问

r1 = {'name':'sss','age':12}
r2 = {'name':'ss','age':112}
r3 = {'name':'s','age':1112}


tb = [r1,r2,r3]

#获得第二行人的年龄
print(tb[1].get('age'))

#打印所有的年龄
for x in range(len(tb)):
    print(tb[x].get('age'))

字典实现的核心底层原理（重要）
字典对象的核心是散列表。散列表是一个稀疏数组(总是有空白元素的数组），数组的每个单元叫做 bucket。每个bucket有两部分︰一个是键对象的引用，一个是值对象的引用。由于，所有bucket结构和大小一致，我们可以通迁偏移量衷读取指定bucket.

将一个键值对放进字典的底层过程

当数组大小不够时，会自动扩容

根据键查找“键值对”的底层过程

用法总结：
①键必须可散列
      a.数字、字符串、元组，都是可散列的
      b.自定义对象需要支持hash()函数、支持通过__eq__()方法检测相等性、若a==b为真，则hash(a)==hash(b)也为真。
②字典在内存中的开销巨大，典型的空间换时间
③键查询速度很快
④往字典里面添加新建可能导致扩容，导致散列表中键的次序变化。因此，不要在遍历字典的同时进行字典的修改。

3.4集合

集合是无序可变、元素不能重身。实际上，集合底层是字典实现，集合的所有元素都是字典中的“键对象”，囚此是不能重复的且唯一的。

集合创建和删除
①使用{}创建集合对象，并使用add() 方法添加元素

>>> a ={12312,20,3,"dd"}
>>> a
{12312, 3, 20, 'dd'}
>>> a.add("adasd")
>>> a
{'adasd', 3, 20, 12312, 'dd'}

②使用set()，将列表、元组等可迭代对象转换成集合。如果原来的数据存在重复数据，则只保留一个。

>>> a = ['a','b',23213]
>>> b = set(a)
>>> b
{'b', 'a', 23213}

③remove()删除指定元素；clear()清空整个集合

>>> b.remove('a')
>>> b
{'b', 23213}
>>> b.clear()
>>> b
set()

集合的相关操作