python数据类型,,方法字符串:strt


方法

字符串:strtype,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是\t
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(‘\n‘)
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
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()dict_items([(‘k1‘, ‘v1‘), (‘k2‘, ‘v2‘)])
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):
如果没有交集,返回一个true
def 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系列

python数据类型

评论关闭