python数据类型

Posted 2020-08-31

方法

字符串：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是\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)表示在第一个位置添加45

li.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系列