Python 序列一章搞定

(以补至字典）

I.序列概述

1，主要对象：

    字符串，列表，元组

2，序列结构

（1）主要对象

• 字符串：引号开头结尾
• 列表：[]
• 元组：()

（2）结构

正索引：            0    1    2    3  ......    9

序列：               e1  e2  e3  e4 ......   e10

负索引               -10  -9  -8   -7 ......   -1

注意：1，索引起始值为0

           2，负索引起始值为-1

           3，索引最大值： len(序列）-1

 

3，访问方式

（1）索引：

   ——s[index]；可以为正负整数，注意index不可越界

（2）切片

• s[start:stop]；获取内容为start：stop-1
• s[start:stop:step]；step为步进值，可以为负数

例如：

s="Hello,world!"
#The first one 
print(s[0])
#The first two
print(s[:2])
#Items after the second one
print(s[2:])

#Output:
#H
#He
#llo,world!

4，遍历

• for循环：每次获得一个值
• while循环：index+1

s="Hello,world!"
for i in s:
    print(i)
    
index=0
while index<len(s):
    print(s[index])
    index+=1

,,,
Output:
H
e
l
l
o
,
w
o
r
l
d
!
H
e
l
l
o
,
w
o
r
l
d
!

,,,

5，序列运输符

• 类别：比较，not（判断是否为真），加法，乘法
• 代码示例：

s="Hello,world!"
b="Hello"
c=",world!"

#add
a=b+c
print(a)

#multiply
d="h"*10
print(d)

#boolean
print(b not in s)

,,,
Output:
Hello,world!
hhhhhhhhhh
False
,,,

6，序列通用函数

函数	说明
len(obj)	获取可迭代对象长度
max(iter,*[,default=obj,key=func])	获取迭代对象中的最大值，func为处理函数
min(iter,*[,default=obj,key=func])	获取迭代对象中的最小值，func为处理函数
val in seq	存在返回True，不存在返回False
val not in seq	与上面相反
all(iter,/)	对于iter中的每一个对象，如果bool(x)都为真，则返回真，反之，返回False
any(iter,/)	对于iter中的每一个对象，如果bool(x)有一个为真，则返回真，反之，返回False
zip(*iter)	将多个可迭代对象合并，返回zip对象
sorted（iteration，/，*，key=None，reverse=False）	对可迭代对象排序，默认为从小到大，返回列表

以max, min函数为例

val=[0,10,3,4,-1,-15,5,2,6]
print(max(val,key=abs))

print(min(val,key=abs))

,,,
Output:
-15
0
,,,

II.字符串

1，定义方式

（1）定义方式：用单引号(')，双引号(")，三引号(''',""")开头结尾。

（2）注意：

• 前后引号要一致
• 内部不能有和首尾的相同的引号

#Wrong way
s='It's a cake.'

#right way
s="It's a cake."
s='It\'s a cake.'

2，字符串类型

• 普通字符串：引号开头结尾
• 原字符串：r开头
• Byte字符串：b开头

注意：1，原字符串不会对转义符转移

           2，Byte字符串一般处理编码数据，媒体数据

3，编码格式

（1）基本概念：

编码格式是计算机科学领域的一项业界标准，包括字符集，编码方案等。Unicode是为了解决传统的字符编码方案的局限而产生的。同为每种语言中的每个字符设定了统一且唯一的二进制编码，以满足跨平台，跨语言的进行转换和处理的要求

（2）常见编码格式：

gbk，utf-6，utf-16，gb2312等

（3）编码格式操作：

注意：编码和解码都必须使用同一种方式

#take utf-8 as example
s="Hello,world"
s1=s.encode("utf-8")
print(s1,type(s1))

s2=s1.decode("utf-8")
print(s2)

4，格式化创建字符串

（1）使用%的格式化

• 占位符：

占位符	说明
%s	对象str方法的返回值
%r	对象repr方法的返回值
%d,%i	数字格式化
%f	浮点数格式化
%.nf	浮点数保留n位小数
%x,%X	数字格式化为16进制（x,X为大小写）
%c	格式化字符及其ASCII码
%e	科学计数法表示的浮点数（e小写）

• 示例：

name="name=%s"%("Sam")
user_id="id=%i"%(1413232)
print(name,user_id)

#Output:name=Sam id=1413232

（2）f字符串格式化

• 语法格式：f'{val}{val}'
• 特点：字符串以f开头，‘f{a}’；a变量必须定义
• 优点：使用更方便
• 示例：

students=["Helen","Sam","Kally"]
grades=[90,67,88]

for name,grade in zip(students,grades):
    line=f"{name}:{grade}"
    print(line)

'''
Output：
Helen:90
Sam:67
Kally:88
'''

5，字符串相关的函数

• 常用函数

函数	说明
str(obj)	将对象转为字符串
sorted(iter,key=None,reverse=False)	对迭代对象排序，返回列表
ord(c)	将字符串转为ASCII码
chr(i)	将ASCII码转为字符
int(str)	将字符串转为数字
float(str)	将字符串转为浮点数

6，字符串相关的操作

• 查找

函数	说明	参数解释
S.find(sub,[start[,end]])	从前向后查找，返回sub在S第一次出现位置，不存在返回-1	start与stop限定查找范围
S.rfind(sub[,start,[,end]])	从后向前查找，功能同上	同上
S.index(sub[,start[,end]])	功能同S.find，不同：子串不存在报异常	同上
S.count(sub[,start[,end]])	返回子串在S中出现次数	同上

• 代码示例：

s="hiahiahiahia"
k1=s.find("hia")
k2=s.find("hia",5)
print(k1)
print(k2)
'''
Output:
0
6
'''

• 替换

方法和参数	说明
S.replace(old,new[,count])	将old用new替换，返回新的字符串
参数：old	旧字符串
参数：new	新字符串
参数：count	替换数量，默认替换所有

• 切分

方法	说明
S.split(sep=None,maxsplit=-1)	从前向后通过sep对S切分，返回切分子串组成的列表
S.rsplit(sep=None,maxsplit=-1)	从后向前切分，功能同上
参数：sep	分隔符号，默认为空字符
参数：maxsplit	指定切分数量，默认所有的都切分

• 拼接

方法	说明
S.join(iter)	使用S将迭代对象中的元素（字符串）
参数：S	指定的连接符
参数：iter	字符串迭代对象

• strip方法：对字符串首尾进行处理

方法	说明
S.strip(chars=None)	从S头尾处理，删除在chars中的元素，如果元素不在chars中，停止删除
S.lstrip(chars=None)	从S的开始位置开始处理，功能同上
S.rstrip(chars=None)	从S的结尾位置开始处理，功能同上
参数：chars	为指定字符集，默认为空白字符

s="  hello,world  "
print(s.strip())
#Output:hello,world

• 字符串开头结尾判断

方法	说明
S.startswith(prefix[, start[, end]])	S以指定子串开头返回True，否则返回False
S.endswith(suffix[, start[, end]])	S以指定子串结尾返回True，否则返回False
参数：Prefix	子串
参数：start	起始索引
参数：end	结束索引

• 字符串大小写转换

方法	说明	返回值
S.lower()	将字符串所有大写转为小写	返回新字符串
S.upper()	将字符串所有小写转为大写	同上
S.title()	字符串标题化，将每个单词首字母大写，其他小写	同上
S.capitalize()	将字符串的首字母大写，其他小写	同上
S.swapcase()	大小写交换	同上

• format方法

1，可以用{}来代替%，且参数的位置与个数不受限

2，指定位置{n}对于第n个参数

3，指定参数{name}

示例：

f="{} age is {}"
print(f.format('Katy', 18))

f="{1} age is {0}"
print(f.format(18,'Katy'))

f="{name} age is {num}"
print(f.format(name='Katy',num=18))

#All of these output: Katy age is 18

• 字符串判断相关方法

方法	说明
S.isalpha()	判断字符串中所有字符为字母
S.isdigit()	判断字符串为一个数字
S.islower()/S.isupper()	判断字符串所有字符为小写/大写
S.isspace()	判断字符串所有字符为空格
S.istitle()	判断字符串中所有单词的首字母是否为大写，而其他字母为小写

III.列表和元组

（一）列表

1，列表的基础

1）定义方式：变量名=[value1，value2,...]（也可以是变量名=[]）

2）理解：容器，可以存放任何变量，支持插入，修改和删除

2，创建方式

1）直接定义，例如 s=[1,2,3,4,5]

2）多维列表，例如 s=[1,2,3,['a','b','c']]

3）使用list函数，例如 s=“hello” list1=list(s)

3，遍历

1）使用for，while遍历

2）访问多维列表list2[3][2]

3）如何遍历多维列表：

• 使用索引
• 借助isinstance()方法

例如：

grades =[["Sherley",88],["Katy",90]]

for people in grades:
    if isinstance(people,list):
        for val in people:
            print(val)
    

4，修改

修改方法： 列表名[key]=value

5，相关函数和方法

• 常见函数

方法	说明
list(iter=(),/)	将迭代对象转换为列表
max/min(iter,[key=func])	获取最大值最小值
len(obj)	获取长度
sum(iter,start-0,/)	迭代对象求和，迭代对象元素必须为数字

• 用于添加元素

方法	说明
l.append(obj)	在列表队尾插入元素
l.insert(index,obj)	指定索引插入元素
l.extend(iter)	在尾部扩展列表，将可迭代对象添加到列表尾部

• 列表统计和查找

方法	说明
l.count(value)	统计value在列表中出现的次数
l.index(value,[start,[stop]])	返回value第一次出现的位置，不存在报异常

• 列表删除

方法	说明
l.pop(index=-1,/)	删除并返回index对应的value，默认为-1
l.remove(value,/)	删除第一次出现value的值，如果不存在则返回异常
l.clear()	清空列表

（二）元组

元组与列表类似，但是不可变。当我们希望数据不发生改变时，我们常使用元组。

1，创建方式

1，直接定义： t1=(1,2,3)

2，使用函数： t2=tuple("123")

2，常用方法

方法	说明
T.count(value)	统计value在元组中出现的次数
T.index(value,[start,[stop]])	返回value第一次出现的位置，不存在报异常

IV.字典

1，基本概念

字典是Python唯一映射性数据结构：

• 字典的定义：{key：value，key2：value}，key在字典中是唯一的
• 字典是一种可变的容器模型，可以存储任意类型对象
• 字典在Python3.6版本中是有序的数据结构

2，字典定义

1）基本形式：key-value

注意，value可以为列表，也可以为字典

2）对key的要求：唯一并且可以hash，例如：

dvalue={1:"hello",1.0:"what"}
print(dvalue)
print(hash(1),hash(1.0))

#Output:
#{1: 'what'}
#1 1

3，字典访问

1）形式：访问单个元素d[key];遍历字典则用for循环进行遍历

4，字典修改

语法：d[key]=value

5，字典相关函数

1）创建字典

• 方法1：d={}
• 方法2：dict()->创建空字典；dict(mapping)->创建字典

例如：

#2-dimention list
d1=dict([['name','sun'],['score',90]])
#tuple with llist
d2=dict([(1,2),(3,4)])
#list and string
d3=dict(['12','34'])

print(d1)
print(d2)
print(d3)

'''
Output:
{'name': 'sun', 'score': 90}
{1: 2, 3: 4}
{'1': '2', '3': '4'}
'''

6，其它函数

方法	说明
key in dict	判断key是否在列表中
max/min(iter,[key=func])	获取字典中key最大值最小值
len(obj)	获取长度
sum(iter)	对字典所有的key求和

7，一些常见的方法

1）fromkeys

dict.formkeys(iter,value=None,/):根据可迭代对象创建字典：

参数介绍：

• iter，迭代对象，每个元素可以hash
• value，设置每个Key的默认值，默认为None

例如：

print(dict.fromkeys(range(1,10),0))
#{1:0,2:0,3:0,4:0,5:0,6:0,7:0,8:0,9:0}

2）获取字符的key和value

方法	说明
D.keys()	获取字典所有的keys
D.values()	获取字典所有的values
D.items()	获取字典每对键值组成的item对象

以遍历字典的键值对为例：

dic={1:"Hello",2:"Hi"}
for k,v,in dic.items():
    print(k,v)

3）get方法

dict.get(key,default=None):获取key的对应值，不存在则返回default值

4）setdefault方法

dict.setdefault(self,key,default=None):添加元素；

• 如果key值存在，返回对应的值，但不添加元素
• 如果key值存在，则在字典中添加元素：{key：default}

5）删除

函数	说明
D.pop(k[,d])	返回并删除k对应的元素，若D中不存在且设置d，返回d，否则异常
D.popitem()	返回并删除一组元素k-v
D.clear()	清空字典

以第一个方法为例：

dic={1:"hello",2:"hi"}
print(dic.pop(2))
print(dic)
print(dic.pop(2,-1))

'''
Output:
hi
{1: 'hello'}
-1
'''

6）更新

方法：D.update([E,]\*\*F)，更新或添加多个元素，E为字典，F为可迭代对象。如果字典内部包含该键值对，更新value；如果没有则添加对象

例如：

dict1={"Katy":80,"Sherly":90}
dict2={"Katy":70,"Jack":90}

dict1.update(dict2)
dict3=dict1
for k ,v in dict3.items():
    print(k,v)
'''
Katy 70
Sherly 90
Jack 90
'''

V.集合

1，定义集合

集合是一个无序的不重复元素序列

定义方式：

• s1={val1,val2,val3,...}(每一个变量都不相同)
• s2=set(iter)

注意：集合不支持索引和切片操作

2，集合相关方法

方法	说明
add(x)	在集合中添加元素
discard(x)	删除集合中的元素
pop()	随机删除一个元素
remove(x)	删除集合中指定元素，元素必须存在于集合中
clear()	清空集合
copy()	拷贝集合
difference(S1,S2,...)	返回S与其他集合的差
difference_update(S1,S2,...)	更新S为与其他集合的差
intersection(S1,S2,...)	返回与其他集合的共同交集
intersection_update(S1,S2,...)	更新S为与其他集合的共同交集
isdisjoint(S1)	两个集合有交集返回False，反之返回True
issubset(S1)	判断当前集合是否为S1的子集
issuperset(S1)	判断S1是否是当前集合的子集
symmetric_difference(S1)	返回S与S1中的不重复元素
symmetric_difference_update(S1)	更新为S与S1中的不重复元素
union(S1,S2,...)	返回S1，S2等与S的并集
update(S1,S2,...)	更新集合S

VI.拷贝问题

1，简介：

• 浅拷贝：拷贝父对象，但不会拷贝对象内部的子对象
• 深拷贝：完全拷贝了父对象及子对象

例如：

浅拷贝中，复制了一个父对象，但内部仍是对原对象的引用，原对象修改会影响复制对象

v1=[1,2,3]
v2=list(v1)
v3=v2

print(id(v1),id(v2),id(v3))
print(v1,v2,v3)

#change v1[0]
v1[0]=-1
print(v1,v2,v3)

#change v2[1]
v2[1]=10
print(v1,v2,v3)

'''
Output:
1390133355392 1390133039424 1390133039424
[1, 2, 3] [1, 2, 3] [1, 2, 3]
[-1, 2, 3] [1, 2, 3] [1, 2, 3]
[-1, 2, 3] [1, 10, 3] [1, 10, 3]
'''

其中v1与v2是深拷贝关系，v2与v3是浅拷贝关系

2，copy模块

浅拷贝：copy.copy(x)

深拷贝：copy.deepcopy(x,memo=None,_nil=[])

例如：

import copy
l1=[1,[2,3]]
l2=copy.deepcopy(l1)
print(id(l1),id(l2))

l1[1][0]=-2
print(l1,l2)
'''
Output:
1390133352384 1390133366464
[1, [-2, 3]] [1, [2, 3]]

'''

VII.Collections模块

1，模块介绍：

Collections模块是对dict,list,set,tuple的扩展，在某些场景下可以替代这些数据类型，其主要包括：

数据类型	说明
Counter	字典的子类，提供了可哈希对象的计数功能
defaultdict	字典的子类，提供了工厂函数，为字典查询提供了默认值
OrderedDict	字典的子类，保证被添加的顺序
namedtuple	创建命名元组子类的工厂函数
deque	类似于列表容器，实现了在两端快速添加（append）和弹出（pop）
ChainMap	类似于字典的容器类，将多个映射集合添加到一个视图里

此处主要介绍比较常用的Counter，defaultdict，OrderedDict，namedtuple

2，Counter

方法	说明
c = Counter(*args, **kwds)	创建Counter对象
c.elements()	返回所有元素组成的迭代器，根据出现次数排序
c.most_common(n=None)	获取出现次数最多的前N个元素
c.subtract(*args, **kwds)	从迭代对象中减去元素
c.update(*args, **kwds)	从迭代对象中增加元素

示例：

from collections import Counter
s = "this is test"
#create Counter
c = Counter(s)
print(c)
#see the element of Counter
print("c.elements():", list(c.elements()))
#increase the element of Counter
c.update(s)
print('update(s):', c)
#decrease the element of Counter
c.subtract(s)
print('subtract(s):', c)
​
'''
Output:
Counter({'t': 3, 's': 3, 'i': 2, ' ': 2, 'h': 1, 'e': 1})
c.elements(): ['t', 't', 't', 'h', 'i', 'i', 's', 's', 's', ' ', ' ', 'e']
update(s): Counter({'t': 6, 's': 6, 'i': 4, ' ': 4, 'h': 2, 'e': 2})
subtract(s): Counter({'t': 3, 's': 3, 'i': 2, ' ': 2, 'h': 1, 'e': 1})

'''

3，defaultdict

collections.defaultdict(default_factory)：为字典key提供一个默认的值。

from collections import defaultdict
#default value is int, 0
d = defaultdict(int)
print(d)
#d['A'], 
print(d['A'])
#d['B'],
print(d['B'])
d['B'] += 1
print(d.items())
'''
Output:
defaultdict(<class 'int'>, {})
0
0
dict_items([('A', 0), ('B', 1)])
'''

4，OrderedDict

Python中字典是无序的，很多时候我们希望字典保留其添加顺序。

OrderedDict：保留字典添加顺序，其操作与dict类似。

from collections import OrderedDict
d = OrderedDict()
d['key1'] = 'value1'
d['key2'] = 'value2'
d['key3'] = 'value3'
print(d)

#Output:OrderedDict([('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3')])

5，namedtuple

使用属性的方式去访问元素

from collections import namedtuple
#3 ways to define namedtuple
Person = namedtuple('Person', ['name', 'age'])
Man = namedtuple('Man', 'name,age')
Woman = namedtuple('Woman', 'name age')
p = Person('sun', 15)
m = Man('li', 15)
w = Woman('zhao', 14)
print('Person:', p.name, p.age)
print('Man:', m.name, m.age)
print('Woman:', w.name, w.age)

'''
Output:
Person: sun 15
Man: li 15
Woman: zhao 14
'''

VIII.总结

1，序列的共同方法和切片

2，字符串，列表，字典，元组，集合的定义方法和常用函数

3，拷贝问题

4，Collections模块中常用的4类