字符串,列表,元组,字典每个常用的5个方法

String常用的字符串操作

# encoding:utf-8
__author__ = 'Fioman'
__date__ = '2018/11/19 15:10'

# 1. 去掉空格和特殊符号
name = " abcdefgeyameng  "
name1 = name.strip()  # 并不会在原来的字符串上操作,返回一个去除了两边空白的字符串
print(name1, len(name1), name, len(name))
# abcdefgeyameng 14  abcdefgeyameng   17

# 去掉左边的空格和换行符
name2 = name.lstrip()
print(name2, len(name2))# print(name2, len(name2))#

# 去掉右边的空格和换行符
name3 = name.rstrip()
print(name3, len(name3)) # abcdefgeyameng 15


# 2.字符串的搜索和替换
name.count('e')  # 查找某个字符在字符串中出现的次数
name.capitalize() # 首字母大写
name.center(100,'-') # 把字符串方中间,两边用-补齐,100表示占位多少
name.find('a') # 找到这个字符返回下标,多个时返回第一个,不存在时返回-1
name.index('a') # 找到这个字符返回下标,多个时返回第一个,不存在时报错
print(name.replace(name,'123')) # 字符串的替换
name.replace('abc','123') # 注意字符串的替换的话,不是在原来的字符串上进行替换.而是返回一个替换后的字符串.

# 3.字符串的测试和替换函数
name.startswith("abc") # 是否以abc开头
name.endswith("def") # 是否以def结尾
name.isalnum() # 是否全是字母和数字,并且至少包含一个字符
name.isalpha() # 是否全是字母,并至少包含一个字符
name.isdigit() # 是否全是数字,并且至少包含一个字符
name.isspace() # 是否全是空白字符,并且至少包含一个字符
name.islower() # 是否全是小写
name.isupper() # 是否全是大写
name.istitle() # 是否是首字母大写

# 4.字符串的分割
name.split('') # 默认按照空格进行分隔,从前往后分隔
name.rsplit() # 从后往前进行分隔

# 5.连接字符串
'.'.join(name) # 用.号将一个可迭代的序列拼接起来

name = 'geyameng'
# 6.截取字符串(切片)
name1 = name[0:3] # 第一位到第三位的字符,和range一样不包含结尾索引
name2 = name[:] # 截取全部的字符
name3 = name[6:] # 截取第6个字符到结尾
name4 = name[:-3] # 截取从开头到最后一个字符之前
name5 = name[-1] # 截取最后一个字符
name6 = name[::-1] # 创造一个与原字符串顺序相反的字符串
name7 = name[:-5:-1] # 逆序截取

列表常用的操作

• 列表的特性
  有序的集合
通过偏移来索引,从而读取数据
支持嵌套
是可变的类型
  列表是一个有序的可以通过索引修改读取数据的支持嵌套的可变的一个数据集合

# encoding:utf-8
__author__ = 'Fioman'
__date__ = '2018/11/19 16:26'

# 1.创建一个列表
list1 = ['1', '2', '3', '4']
list2 = list("1234")
print(list1, list2)
print(list1 == list2)
# 以上创建的两个列表是等价的,都是['1', '2', '3', '4']

# 2.添加新元素
# 末尾追加
a = [1, 2, 3, 4, 5]
a.append(6)
print(a)

# 指定位置的前面插入一个元素
a.insert(2, 100)  # 在下标为2的前面插入一个元素100
print(a)

# 扩展列表list.extend(iterable),在一个列表上追加一个列表
a.extend([10, 11, 12])
print(a)

# 3.遍历列表
# 直接遍历
for i in a:
    print(i)

# 带索引的遍历列表
for index, i in enumerate(a):
    print(i, index)

# 4.访问列表中的值,直接通过下标取值.list[index]
print(a[2])

# 从list删除元素
# List.remove() 删除方式1:参数object 如果重复元素,只会删除最靠前的.
a = [1,2,3]
a.remove(2) # 返回值是None

# List.pop()  删除方式2:pop 可选参数index,删除指定位置的元素 默认为最后一个元素
a = [1,2,3,4,5]
a.pop()
print(a)

a.pop(2)
print(a)

# 终极删除,可以删除列表或指定元素或者列表切片,list删除后无法访问
a = [1,2,3,4,5,6]
del  a[1]
print(a) # 1, 3, 4, 5, 6]

del a[1:]
print(a) # 1

del a
# print(a) # 出错,name a is not defined


# 排序和反转代码
# reverse 反转列表
a = [1,2,3,4,5]
a.reverse()
print(a)

# sort 对列表进行排序,默认升序排列.有三个默认参数cmp = None,key = None,reverse = False

# 7.Python的列表的截取与字符串操作类型相同,如下所示
L = ['spam','Spam','SPAM!']
print(L[-1]) # ['SPAM']

# 8.Python列表操作的函数和方法
len(a)  # 列表元素的个数
max(a)  # 返回列表元素最大值
min(a)  # 返回列表元素最小值
list(tuple) #将一个可迭代对象转换为列表

# 列表常用方法总结
a.append(4)
a.count(1)
a.extend([4,5,6])
a.index(3)
a.insert(0,2)
a.remove()
a.pop()
a.reverse()
a.sort()

字典概述

字典是通过键值对来存储数据的一种数据结构,字典是工作键值映射来存取数据的.
数据的访问时通过键,而不是索引.并且字典的无序的可变的序列.

创建字典的方法

• 创建一个空字典

D = {}  或 D = dict()

• 通过键构建值都为None的字典

D = dict.fromkeys(['a','b','c'])  ==> {'a':None,'b':None,'c':None}

• 通过zip函数构建字典

D = dict(zip(keyslist,valueslist))

• 通过赋值表达式元组构造字典(键必须是字符串,因为如果不是字符串,构造的时候也会当成是字符串处理)

D = dict(name='Bob',age=42)  ==> {'name':'Bob,'age':42}

• 成员关系(判断的是key,和value没有关系.字典的成员关系判断只判断key)

if key in D:
  pass

• 列出所有的键,值.注意得到的是一个可迭代对象,而不是列表.用的时候需要转换

D.keys()     D.values()  D.items()  --> 键 + 值

• 拷贝一个字典的副本 (浅拷贝)

D1 = D.copy()

• 已知字典的键,获取其对应的值,如果不存在,提供一个默认值. 如果没有提供默认值,这个键对应的值又不存在的时候,就会引发错误.

d_value = D.get(key,default)

• 合并更新字典

D.update(D2)

• 删除字典(根据键)以及长度

D.pop(key)    len(D) del D[key]

• 新增或者是修改键对应的值

D[key] = value  # 如果key已经存在则修改,如果不存在就创建.

• 字典键的列表,值的列表

list(D.keys())   list(D.values())

• 字典推导式

D = [x:x**2 for x in range(10) if x %2 == 0]

• 字典使用事项

1)序列运算无效(字典是映射机制,不是序列)
2)对新索引的赋值会添加新的键值对
3)键不一定总是字符串(任何不可变对象都可以作为键).

• 使用字典模拟灵活的列表
  问题? 我们都知道使用列表的时候,对在列表中的末尾的偏移赋值时是非法的

L = [1]
L[1] = 2 # 这里会报一个index out of range 的错误.

可以用字典解决这个问题,使用整数作为键时,字典可以效仿列表在偏移赋值时增长.
可以用字典解决这个问题,使用整数作为键时,字典可以效仿列表在偏移赋值时增长
D = {}
D[0] = 1
D[1] = 2

补充,创建字典的方法

• 如果你事先可以拼接出整个字典,可以这么来创建

D ={'name':'fioman','age':45}

• 如果你需要动态的创建一个字典,可以这么来创建

D = {}
D['name'] = 'fioman'
D['age'] = 45

• 如果键都是字符串,并且所有的键的值都知道,则可以这么来创建

D = dict(name = 'Fioman',age = 4)

• 可以根据两个序列构成一个字典

dct(['name','fioman',('age',45)])

元组

元组概述

• 任意对象的有序集合,可以通过序列取值
• 元组不可变的序列的操作类型
• 固定长度,异构,嵌套(元组里也可以包含元组)
• 对象引用的数组

常见的操作

1. 创建空元组

t1 = ()
t2 = tuple()

2.单个元素的元组记得一定加,

x = (40)  ==> int数 40
x = (40,) ==> 一个元组,具有一个元素的值是40

3.多元组的两种表达方式

T  = (1,2,3)  # T = 1,2,3  括号可以省略

4.用一个可迭代对象生成元组

T = tuple('abc')

5.元组的访问

T[i]  T[i][j]

6.合并和重复

T1 + T2   T * 3

7.迭代和成员关系

for x in T:
  print(x)

'spam' in T

8. 对元组进行排序
   注意
   当对元组进行排序的时候,通常先得将它转换为列表并使得它成为一个可变对象.或者使用
   sorted方法,它接收任何序列对象.

T = ('c','a','d','b')
tmp = list(T)
tmp.sort()  ==> ['a','b','c','d']
T = tunple(tmp)
sorted(T)

9.为什么有了列表还要元组

a. 元组可以看成是简单的对象组合,而列表是随着时间而改变的数据集合
b. 元组的不可变性提供了某种完整性.这样可以确保元组不会被另外一个引用来修改.
元组有点类似于其它语言中的常数声明.

集合

集合概述

集合内的元素必须是不可变的,而它本身是可变的容器,集合是无序的,并且里面存放的对象是唯一的不重复的
集合是可迭代的对象,集合相当于是只有键没有值的字典,集合可以作为字典的键.

集合的操作

• 创建空集合

a = set() 
# 注意不能是 a = {} 这是空字典
b = set(iterable) # 用可迭代对象创建一个集合

• 集合的运算

& 生成两个集合的交集 s3 = s1 & s2
| 生成两个集合的并集 s3 = s1 | s2
-生成两个集合的补集 s3 = s1 - s2
^ 对称补集 s3 = s1 ^ s2 (只能属于s1或者s2 ,也就是去除掉s1和s2重合的部分)

• 集合的特殊符号

判断一个集合是否是另外一个集合的超集
< 判断一个集合是否是另外一个集合的补集