方法
字符串：str
type,dir;dir看到的是类里面的所有成员，方法只是在其中里面。
vars不仅把成员列出来，还把成员的
name = str('eric')
自动调用str类的__init__方法。result = name.__contains__('er')
等同于 in 方法。result ='er' in name还有一种%s，也是一种字符格式化。不能用+号。
__format__ 字符串的格式化。
__getattribute__(self, *args, **kwargs):在反射的时候用到。
__getitem__(self, *args, **kwargs)在面向对象中有，例如dic['key']就是默认调用这个方法
capitalize(self):首字母大写。
casefold(self):首字母小写
center(self, width, fillchar=None)
result = name.center(20)
result = name.center(20,'*')
********eric********
居中， ljust(self, width, fillchar=None)居左
count(self, sub, start=None, end=None)
result = name.count('s',0,10)
某个子序列出现的次数。还可以规定起始位置和结束为止。encode(self, encoding='utf-8', errors='strict'):python3里面默认是utf-8，他自己在内容默认转化成的utf-8的过程，如果是python2中，要先decode转换成Unicode，在encode转化为utf8；
endswith(self, suffix, start=None, end=None)判断是以什么字符结尾的，返回bool值。
expandtabs(self, tabsize=8)转化，把tab转化为空格，默认一个tab转换为8个空格。可以自定义。tab是
find(self, sub, start=None, end=None)去字符串找某个子序列，然后返回这个字序列的位置，可以设置起始位置和结束位置
index也可以找，返回位置， 但是index找不到直接报错，find找不到返回-1
format(self, *args, **kwargs)字符串格式化，把字符添加进去。
name = 'adf{0}{1}'#name='adf{}{}'#name='adf{name}{id}'
result = name.format('aadsf','12354')#format(name='jam',id='35465')
format_map(self, mapping)
join(self, iterable)
li = ['a','b','c']
result = ''.join(li)
输出结果：abc
lstrip(self, chars=None):strip是两边空格全去掉，lstrip是只去掉左边的，rstrip是去掉右边的。
def maketrans(self, *args, **kwargs):
translate(self, table):这两个是一起使用。就是做一个替换，a替换1，xm删除。
partition(self, sep):做分割：将字符串分割为三部分。
replace(self, old, new, count=None):替换
把a全部替换成o
split(self, sep=None, maxsplit=-1):指定字符，然后分割字符串。
splitlines(self, keepends=None):根据行来进行分割。其实是根据换行符来进行替换的。等同于split(' ')
startswith(self, prefix, start=None, end=None):以什么开头。
swapcase(self):大小写进行转换，把大写转为小写，小写转为大写。
title(self):把所有字母的开开头大写。
upper(self)大写
zfill(self, width):自动补齐。
用的最多的是，split、strip、join、replace。
在博客中一句一句的去敲例子写在博客中。具备到这个类里面查看方法，有意向是哪个实现某种功能。
列表
list:有序
特点：常见类型，存放多个元素，类型不限, 元素可以任意操作。
创建方式：
li = [11,2,3]
li = list(11,22,33)
在python中一切事物皆为对象，list是一个类，使用类的方法创建对象，也可以使用直接等于的形式，但是第一种形式是python的语法糖形式，其实也是执行了下面这种方式。
常见方法：
li = list([1,2,3])#list((1,2,3))
def append(self, p_object):
列表的尾部添加元素
li.append(4)
结果：[1, 2, 3, 4]
def clear(self):
列表清空def copy(self):
这里的拷贝是浅拷贝，还有深拷贝。def count(self, value):
元素出现的次数li.count(2)
结果：1
def extend(self, iterable):
合并两个列表或者列表和元组合并。合并元组是依旧成为列表的形式。li.extend([5,6])
结果：[1, 2, 3, 4,5,6]
def index(self, value, start=None, stop=None):
获取元素的下标，找到的是第一个值，可以选择开始寻找的位置和结束的位置。li.index(4)
结果：3
结果：3
def insert(self, index, p_object):
append是向列表最后添加，insert想在哪里放就在哪里放。insert(1,45)表示在第一个位置添加45li.insert(1,1.5)
[1, 1.5, 2, 3, 4, 5, 6]
def pop(self, index=None):
在最后删除（或者指定下标 ret = li.pop(0)），会返回一个值，返回拿出去的那个值。def remove(self, value):
指定的是一个值，li.remove('11'),只拿出第一个。不返回值
def reverse(self):
反转。将元素全部反转。li.reverse()
[6, 5, 4, 3, 2, 1.5, 1]
def sort(self, key=None, reverse=False):
排序li.sort()
[1, 1.5, 2, 3, 4, 5, 6]
这里面只有pop返回一个值，其他的都直接在列表里面进行操作。
字典
dict：无序
my_dict ={'k1':'v1','k2':'v2'}
my_dict = dict(['k1':'v1','k2':'v2'])#括号内的是以序列的方式传入，所以直接生成字典的形式。
特点：键值队，常用的数据类型
常见方法：
dic = dict('k1'='v1','k2'='v2') dic = {'k1':'v1'}
两种创建方法都相同def clear(self):
清除字典中的元素
def copy(self):
拷贝元素，潜拷贝
def fromkeys(*args, **kwargs):
取出多个key，然后可以赋值成一个value，python3中新添加的方法
从字典里面拿出一个key然后赋值生成一个新的字典。
def get(self, k, d=None):
重点：dic.get('k3'),这个值不存在也不会报错，返回一个None，如果不存在设置一个值：dic.get('k3','as')如果使用dic['k3'],这个值不存在的话，编译的时候会报错
def items(self):
返回所有的键值对，
dic = {'k1':'v1','k2':'v2'}
dic.items()
dic.items()
dict_items([('k1', 'v1'), ('k2', 'v2')])
for i in dic.items():
for i in dic.items():
print (i)
('k1', 'v1')
('k2', 'v2')#返回元组
拿出所有的key,values,items，可以进行for循环，取出所有的值。for k ,v in dic.items()
def pop(self, k, d=None):
不加参数会报错，拿走一个key，返回这个key的值。def popitem(self):
没有参数，随机拿走一个，因为字典是无序的，返回值为一个元组('k1', 'v1')def setdefault(self, k, d=None):
设置一个默认值
def update(self, E=None, **F):
更新这个字典 ，就在这个字典基础上;如果没有更新，那就是返回一个值。方法1：
li = [11,22,33,44,55,66,77,88,99,111]
l1 = []
l2 = [] for i in li : if i >66:
l1.append(i) elif i <=66:
l2.append(i)
dic = {'k1':l1,'k2':l2} print (dic)
{'k1': [77, 88, 99, 111], 'k2': [11, 22, 33, 44, 55, 66]}
方法2：
li = [11,22,33,44,55,66,77,88,99,111]
dic = {} for i in li: if i >66: if 'k1' in dic.keys():
dic['k1'].append(i) else:
dic['k1'] = [i,]# else: if 'k2' in dic.keys():
dic['k2'].append(i) else:
dic['k2'] = [i,]# print (dic) #此处直接让k2的值生成一个列表类型
{'k1': [77, 88, 99, 111], 'k2': [11, 22, 33, 44, 55, 66]}
方法3：
li = [11,22,33,44,55,66,77,88,99,111]
dic = {'k1':[i for i in liif i > 66],'k2':[ i for i in liif i<=66]}
print(dic)
这中方法更加简洁，且执行效率更高。方法4：默认字典values值是空列表，引用了collections模块中的默认字典。让字典value默认为一个列表类型。
元组
tuple：无序
特点：元素不能修改，不能插入，可以查找
my_tuple = (11,22,33)
my_tuple = tuple([11,22,33])
例外：元组里面的元素的元素可以进行修改
例如：
t1 = (1,2,{'k1':3})
t1[2]['k1']=4
输出结果：t1 = (1,2,{'k1':4})
方法：
index
集合
set：无序
特点：元素不能重复，访问速度快，常用于爬虫中去重。
set创建和上面有所区别，因为不是常用的类型，所以只有以类--对象的形式创建
s1 = set(['a','b','c'])
常见方法：
def add(self, *args, **kwargs):
添加一个元素，重复添加自动去重
s1.add('asdf')
{'asdf'}
def clear(self, *args, **kwargs)
清空数据def copy(self, *args, **kwargs):
浅拷贝def difference(self, *args, **kwargs):
s1 = set(['a','b','c'])
s2 = set(['a',123,'b',64])
s3 = s2.difference(s1)
print (s3){64, 123}
判断两个不同的集合，取出不同的部分返回形成一个新的set；def difference_update(self, *args, **kwargs)
不返回值，就在原来的基础上进行修改。删除参数集合里面的相同元素def discard(self, *args, **kwargs):
移除元素s1.discard('a')
def intersection(self, *args, **kwargs):
取交集：
返回一个值
def intersection_update(self, *args, **kwargs)
取出交集，修改原来的集合，不返回值
def isdisjoint(self, *args, **kwargs):
如果没有交集，返回一个truedef issubset(self, *args, **kwargs):
是否是子集def issuperset(self, *args, **kwargs):
是否是父集
def pop(self, *args, **kwargs):
移除，返回移除的这个值。默认移除第一个
def remove(self, *args, **kwargs):
移除，不获取这个值，没有参数随机删除，加参数表示要删除那个一个def update(self, *args, **kwargs):
更新，不返回值symmetric_difference（self,args）
s1 = set([11,22,33]) s2 = set([22,44]) ret1 = s1.difference(s2) ret2 = s1.symmetric_difference(s2) print (ret1,ret2)
{33, 11} {33, 11, 44}
symmetric_difference#两边不相同的元素都取出来。
计数器：
collection系列
Counter 是对字典的一个加工；相当于把元素设为key，出现的次数设为value，然后以字典的形式输出，但不是真正的字典。输出是无序的。
import collections
obj = collections.Counter('adfdfsdf')
print (obj)
Counter({'d': 3, 'f': 3, 'a': 1, 's': 1})
把里面出现的次数记录成字典。看着是字典但是不是，需要使用方法elements
方法：
def most_common(self, n=None):拿到前几位。目前没有用在生产上。
def elements(self):做循环用的。取出所有的元素。
for k in obj.elements():#循环已经处理完的数据。
a
d
d
d
f
f
f
s
print(k)
for k ,v in obj.items():#循环出所有kesy和values
print(k,v)
a 1
s 1
f 3
d 3
def update(*args, **kwds):添加
obj.update('sd')
def subtract(*args, **kwds):删除，没有出现次数就显示-1；
有序字典:（列表是有序的）
orderedDict是对字典的类型的补充，内部就是用一个列表来维护，因为列表是有序的。
方法和字典里面一模一样。
方法：obj.popitem()取出最后插入的，后进先出。
ret = obj.pop('k2')指定key拿出来。返回一个值
效果等同
默认字典：
就是设置一个默认类型，默认字典的values是一个列表类型。
可命名元祖
可命名元组：（不支持修改）可以定制自己可命名元组，坐标的时候可以用到这个方法。
