python常用序列及相关方法介绍

---

列表详解

这里对列表常用方法做了一个整理，也是便于必要时查阅吧。

列表的创建与删除

• 列表可以通过“[]”创建或者list函数转化。

  listname=['a','b']
  listname = []		# 创建空列表
  listname = list(range(0,100,2))		# 通过list函数转化得到列表
  del listname		# 删除列表
  

---

列表的一些方法

• append：尾部添加单个元素

  ls = []
  for each in range(100):
  	if each % 2 == 0:
  		ls.append(each)
  

• extend：尾部添加一个列表所有元素

  ls = [1,2,3]
  ls_extend = [4,5,6]
  ls.extend(ls_extend)
  
  '''也可以在中间位置插入一个列表的所有元素'''
  ls[1:1] = ls_extend
  

• remove：删除元素

  ls = [1,2,3]
  del ls[2]		# 删除指定索引列表元素：3
  ls.remove(2)		# 移除列表元素：2
  

• pop：删除指定index元素，默认是最后一个，并返回删除元素

  ls = [1,2,3]
  ls.pop(1)
  # out:2
  

• reverse：列表元素反转

  ls = [1,5,2]
  ls.reverse()
  print(ls)
  # out:[2,5,1]
  

• index：获取指定元素的索引号

  ls =  [1,2,3]
  ls.index(2)
  # out：1
  

• count：获取列表中元素出现的次数

  ls = [1,2,1,5,2]
  ls.count(2)
  # out:2
  

• sort：排序
  key用于提取比较的关键字，比如长度（lambda x : len(x)）。reserve=Flase 升序，默认为升序。True降序；函数本身不会返回

  ls = [1,3,8,2]
  ls.sort(key=lambda x:x%2,reverse=True)
  '''sorted方法不会改变原来列表排序'''
  ls_1 = sorted(ls,key=None,reverse=True)
  

• insert：指定位置插入元素
  ls.insert(index,object)：index-插入的索引位置

  ls = [1,2,4]
  ls.insert(1,88)
  print(ls)
  # out:1,88,2,4
  

• min、max、sum：最小值、最大值、求和（元素为数值型）

  ls = [1,2,4]
  ls_sum = sum(ls)
  ls_min = min(ls)
  ls_max = max(ls)
  

• 修改列表元素

  ls = [1,2,3]
  ls[1] = 88
  print(ls)
  # out: [1,88,3]
  

列表切片

• 左闭右开，第一个参数为起始位置，第二个参数为结束位置（开），如果为负表示倒数第几个，第三个参数为切片间隔，如果为负数表示逆序切片，可以利用这个反转列表元素顺序。

ls = [1,2,4,7,88]
ls[:2]
# out:[1,2]
ls[:-1]
# out: [1,2,4,7]
ls[::-1]
# out：[88,7,4,2,1]

• 二维列表及其切片

a=[['a','b','c'],[1,2,3]]
a[1][2]
# out:3

• tuple：将列表转化为元组（元组元素不可变）

ls = [1,2,3]
tup = tuple(ls)
print(tup)
# out: (1,2,3)

列表推导式

表达式expression也可以使用自定义函数。比如f(x)
- [expression for var in list]

a =[1,3,5,6,9] 
b = [x**2 for x in a]

def f(data):
	return data + 1
b = [f(x) for x in a]		#使用自定义函数

• [expression for var in list if condition]

a =[1,3,5,6,9] 
b = [x**2 for x in a if x > 3]

• [expression if condition else expression for var in list]

a =[1,3,5,6,9]
b = ['奇数' if x%2 != 0 else '偶数' for x in a]

• [x for a in b for x in a]：二维列表推导式应用

'''对列表中元素为列表的所有子元素求和'''
l = [[1,2],1,[1,2,3],4,[6,7]]
s = sum([x for y in l if isinstance(y,list) for x in y])
'''我们把列表推导式展开，这样获取变得好结构清楚些'''
def list_expend():
	ls = []
	for y in l:
		if isinstance(y,list):
			for x in y:
				ls.append(x)
	return ls

---

列表拆包

• 某些情况下，我们可能需要取列表中的几个值，这样我们可以使用了列表切片来逐一赋值，此外我们还可以使用‘*’列表拆包一步到位。

prop = ['张三','男','70kg',18,'178cm']
'''我们获取列表中的姓名和性别元素'''
name,sex,*_ = prop
print(name,sex)
# out：('张三', '男')
'''姓名，年龄，身高'''
name,*_,age,height = prop
print(name,age,height)
# out:('张三', 18, '178cm')

'''成绩：去除最大值最小值='''
grade = [80,75,23,100,85]
_,*grade_valid,_ = sorted(grade) 
print(grade_valid)
# out:[75, 80, 85]

其他

• 通过slice生成可切片对象，赋值给变量，很多时候往往使得代码可读性更好，比如下面：

dt = '20190714'
year = slice(0,4)	# 生成切片对象slice
print(dt[year])

注意事项：部分函数是没有返回值的，大家将一些方法赋值给变量，变量结果可能是NoneType~~

---

元组

列表与元组的区别

1. 都属于序列；列表可以用append（），extend()，pop()，insert()函数，元组属于不可变序列，除非整体替换；
2. 元组也可以通过切片访问元素，但元组不能通过切片修改元素；
3. 元组比列表的处理和访问速度更快；
4. 列表不能作为字典的key，而元组可以。
5. 元组推导式与列表基本一致。

元组的创建与删除

python元组定义可以不加小括号，但不建议；比如当做参数传递时，不加括号被被解释器理解为多个变量参数传入；

a = (1,2,3)	
a = 1,2,3	   
a = (1,)
# type()函数可以检测测试变量的类型
# 创建空元组
a=()
# 创建数值元组——tuple()函数可以通过列表等创建元组。
a = tuple(range(10))
# 删除元组
del tuplename

---

字典

字典的特征

1. 通过键而不是索引来读取；
2. 字典是任意对象的无序组合；
3. 字典是可变的，并且可以任意嵌套；
4. 字典中的键必须是唯一的；
5. 字典中的键必须不可变，可以使用数字，字符串或者元组，但不能使用列表。

字典的创建与删除

dictionary={'a':1,'b':2,'c':3}
# 空字典两种创建：
a={}	
a=dict()

# 通过映射函数创建字典
# zip()将多个列表或元组转化为对偶元组。
list1=['a','b','c','d']
list2=[1,2,3,4]
print(dict(zip(list1,list2)))

# 通过给定的‘键-值对’创建字典
dictionary=dict(key1=item1,key2=item2......)
print(dict(a=1,b=2,c=3))

# 使用dict的fromkeys()方法创建键值为空的字典。
a=dict.fromkeys(list1)	# list1为元组或列表

# 可以通过已经存在元组列表创建字典
a={tuplename:listname or tuplename}	  # 第一个参数key只能用元组，列表不能作为字典的key；
c={tuple(list1):list2}

# 删除字典
del dictionary

# 清空字典（原字典变为空字典）
dictionary.clear()

# 把字典dic2键值对导入到字典dic1中
dic1.update(dic2)

字典访问

print(dictionary['keyname'])
# 在实际操作中，可能因为不知道存在什么键，不存在是结果会报错。可以用以下代码：
print(dictionary[keyname] if 'keyname' in dictionary else '我的字典没有这个key')

# 也可以用get方法获得指定键的值
dictionary.get(key,[default])	第二个参数：找不到键值返回该内容
print(dic.get('ccc','没有找到该键，返回自定义值'))

字典遍历

dictionary.items()	  # 返回字典的‘键-值对’
dictionary.keys()     # 返回字典的key
dictionary.values()	  # 返回字典的值
# 遍历语句：
for key , value in dictionary.items()
print(key , value)

添加、修改、删除字典元素

# 添加	   
dic[key]=value
# 删除元素    
del dic[key]

字典推导式

import random
a = {a:random.randint(1,10) for a in range(10)}
print(a)
#  根据列表生成字典
a=['a','b','c'] 
b=[1,2,3]
print({a:str(b) + '斤' for a , b in zip(a,b)})

---

集合

创建集合

• 使用大括号

a={1,2,3}
a = set([1,4,5])    # set函数可以将列表、元组导入到集合中（可以实现去重功能）。
set([1,2,3,1,2,3])
# {1, 2, 3}

添加或删除元素

# 添加,element只能是字符串、数字及布尔不能使用列表元组等迭代对象。
setname.add(element)   
# 删除 
setname.remove("删除元素")	# 删除指定元素
setname.pop()   # 移除第一个元素，无参数传递
setname.clear()  # 清除集合
del  setname	# 删除集合

集合运算

• 可以用来做交集、差集、并集，比如号码包处理；

# 交集：
setname1 & setname2
# 并集：
setname1 | setname2
# 差集：
setname1 - setname2

字符串

字符串是不可变序列，同列表有所不同；

s1 = "a"
s2 = s1
print(id(s1),id(s2))   # 两个指向同一块内存
s2 = "b"    # 系统为对象“b”申请一块新的内存空间，s2指向新地址
print(id(s2))   # 不同于id(s1)

'''列表：可变序列'''
ls1 = [1,2,3]
ls2 = ls2
print(id(ls1),id(ls2))    # 一样的
ls2.append(50)   # [1,2,3,50]
print(ls1 is ls2)    # ls1也跟着修改，两个引用指向同一个对象，返回True    
print(id(ls1),id(ls2))    # 还是一样的

判断字符串性质

是否字符串：isinstance(s,str) ，该函数可以用来判断对象类型，第二个参数可以以元组传入多个类型判断，比如：isinstance(5,(str,int))int类型匹配，返回True
len(str)可判断字符串长度
字符串性质：

• isalnum()：是否由字母和数字组成
• isalpha()：是否都是字母
• isdigit()：是否只由数字组成
• islower()：是否都是小写
• isupper()：是否都是大些
• isspace()：是否是空白符
• istitle()：单词首字母是否大些，比如：'Hello World'.istitle()
• startswith(prefix[, start[, end]])：字符串是否是以指定子字符串开头，后面两个参数是指定开头结尾范围内查找，比如：'abc'.startswith("b",1)返回True
• endswith(suffix[,start[, end]])：字符串是否是以指定子字符串结尾

查找与替换

• count(sub[, start[,end]]): 检索指定字符串在另一个字符串里边出现的次数。如果检索的字符串不存在，则返回0
• find(sub[, start[, end]]): 查找一个较长字符串子串在最左端的索引，不存在返回-1，如果是判断字符串是否包含子串，可以用in方法：'sub' is in 'substring'返回True
• index(sub[,start[, end]]): 找出索引位置，找不到抛出异常
• rfind(sub[, start[,end]])：从右边开始查找，类似于find
• rindex(sub[, start[, end]]): 类似于index
• replace(old, new[,count])：
• partition(sep)：如果能被分割，返回sep左侧，sep，sep右侧三元素，三元组，不存在返回(sep, '','')，比如：- - 'a,b'.partition(',')返回('a', ',', 'b')
• rpartition(sep)
• splitlines([keepends])
• split([sep[,maxsplit]]): 按sep分割，返回数组，maxsplit分割次数，默认最大，比如：'a,b'.split(',')返回['a','b']
• rsplit([sep[,maxsplit]])：类似于split，从右侧分割

变形

• lower()：大写字母转化为小写，比如'ABC001'.lower()
• upper()：小写转化为大写
• capitalize(): 每个字词以使其首字母大写，再用空格将它们连接在一起
• swapcase(): 返回大小写字母转换后生成的新字符串
• title(): 将每一个单词的首字母大写，并将单词中的非首字母转换为小写

排版

• strip([chars])：默认去重两边空格，亦或剔除指定字符，比如：'abc '.strip(' bc')返回'a'
• lstrip([chars]): 从左侧剔除
• rstrip([chars])：右侧剔除
• center(width[, fillchar])：居中，fillchar是填充参数，默认空格，'居中'.center(15)
• ljust(width[,fillchar])：居左
• rjust(width[, fillchar])：居右
• zfill(width)：左侧填充指定长度的0，'123'.zfill(15)
• expandtabs([tabsize]): tabsize参数默认为8，把字符串中的制表符（tab）转换为适当数量的空格

编码与解码

'asdf'..encode('utf-8')：编码为utf-8
b'asdf'.decode()：解码

format格式化

• 按位置填充: '我是{},我今年{}岁。'.format('007',17)，默认是顺序填充的，也可以指定位置填充：'{1}abc{0}'.format(2,1)返回：'1abc2'
• 使用关键字参数：

d = {'name':'007','age':17}
'我是{name},我今年{age}岁。'.format(name='007',age=17)
# 可用字典当关键字参数传入值，字典前加**即可
'我是{name},我今年{age}岁。'.format(**d)

• 对齐：[填充字符][对齐方式 <^>][宽度]，'{0:*^20}'.format(10)，返回'*********10*********'
• 精度与进制
  '{0:.2f}'.format(1/3)：保留两位小数点'0.33'
'{0:b}'.format(10)：二进制'1010'
'{0:o}'.format(10)：八进制'12'
'{0:x}'.format(10): 16进制'a'
'{:,}'.format(12369132698) 千分位格式化，返回'12,369,132,698'