Python3数据类型

最近在学习Python，记录一下学习笔记

 

Python3 一般常用数据类型实例：

int 

"""
int内部功能
"""

#返回该数字占用的最少位
num = 888
result = num.bit_length()
print(result)

#返回该复数的共轭复数
num = 888
result = num.conjugate()
print(result)

#返回绝对值
num = -888
result = num.__abs__()
print(result)

#相加
num = 10
result = num.__add__(10)
print(result)

#相除，得到商和余数，返回的是一个元组类型
num = 10
result = num.__divmod__(3)
print(result)

#相除，得到商，返回整数
num = 10
result = num.__floordiv__(3)
print(result)

#转换为浮点类型
num = 10
result = num.__float__()
print(result)

#格式化
result = '{0} is {1}'.format("eric","sb")
print(result)

#返回当前数字的十六进制值
result = hex(10)
print(result)

#转换为整数
num = 10.9
result = num.__int__()
print(result)

按位求反
#num = 10
result = num.__invert__()
print(result)

#或
num = 10
result = num.__or__(10)
print(result)

#幂次方
num = 10
result = num.__pow__(2)
print(result)

#转换成解析器可阅读的格式
num = 10
result = num.__repr__()
print(result)

#转换成人可阅读的格式
num = 10
result = num.__str__()
print(result)

str

"""
字符串内部功能
"""

#字符串居中，两边空出20个空格，空格用"*"代替
name = "Eric"
result = name.center(20,"*")
print(result)

#右边空出20个空格
name = "eric"
result = name.rjust(20)
print(result)

#左右空出20个空格
name = "eric"
result = name.ljust(20)
print(result)

#统计字符串里某个字符出现个数，可定义索引开始和结束位置
name = "sdfsrhshdkfk"
result = name.count("sh",5,10)
print(result)

#转换编码
name = "李连"
result = name.encode("gbk")
print(result)

#查找字符串里包含某个字符，可定义索引开始和结束为止
name = 'alex'
result = name.endswith('e',0,3)
print(result)

#table转空格
name = 'a   lex'
result = name.expandtabs()
print(result)

#查找字符串内容，返回个数，如果没有返回负数
name = "alex"
#result = name.find("x")
print(result)

#查找字符串内容，返回个数，如果没有报错
name = "alex"
result = name.index("x")
print(result)

#格式化字符串,和%s类似
name = "{0} as {1}"
resutl = name.format('alaex','sb')
print(resutl)
name = "alex {name} as {id}"
result = name.format(name="sb",id="eric")
print(result)

#拼接字符串
li = ["s","b","a","l","e","x"]
result = "_".join(li)
print(result)

#大写转小写
name = "SLDKFSLDF"
result = name.lower()
print(result)

#小写转大写
name = "SLDKFSLDF"
result = name.upper()
print(result)

#所有大小写转换
name = "  SLDKFSLDF "
result = name.swapcase()
print(result)

#所有单词的首字母大写
name = "luo alex"
result = name.title()
print(result)

#去掉空格
name = "  SLDKFSLDF "
result = name.strip()
print(result)

#去掉左边空格
name = "  SLDKFSLDF "
result = name.lstrip()
print(result)

#去掉右边空格
name = "  SLDKFSLDF "
result = name.rstrip()
print(result)

#按字符串分割(不丢弃分隔符)
name = "alexissb"
result = name.partition("is")
print(result)

#按字符串分割(丢弃分隔符)
name = "alexissb"
result = name.split("is")
print(result)

在每行前面添加换行符
name = """
alex
is
sb"""
result = name.splitlines()
print(result)

#替换,转换前2个
name = "aalexisasb"
result = name.replace("a","o",2)
print(result)

dict 

"""
dict内部功能
"""

#清空字典
dict = {'k1','k2'}
print(dict.clear())

#浅拷贝
dict = {'k1','k2'}
dict2 = dict.copy()
print(dict2)

#深拷贝
import copy
dict = {'k1','k2'}
dict2 = copy.deepcopy(dict)
print(dict2)

#指定字典key，并设置一个默认值，重新生成一个新的字典
dict = {'k1':'v1','k2':'v2'}
dict2 = dict.fromkeys(['k1','k2','k3'],'www')
print(dict2)

#获取字典key值value，key不存在返回"None",(可指定默认参数，当key不存在返回默认值)
dict = {'k1':'v1','k2':'v2'}
dict2 = dict.get("k4",'eric')
print(dict2)

##获取字典的键值对，返回一个可迭代对象
dict = {'k1':'v1','k2':'v2'}
#获取key
for n in dict.keys():
    print(n)
#获取valus
for i in dict.values():
    print(i)
#items可以同时获取key和valus
for k,v in dict.items():
    print(k,v)

#移除一个指定的键值(因dict和list不一样，dict是有序的，必须要指定一个key)
dict = {'k1':'v1','k2':'v2'}
result = dict.pop('k1')
print(result)

#随机移除一对键值
dict = {'k1':'v1','k2':'v2','k3':"v3"}
result = dict.popitem()
print(result)

#给dict的key设置一个默认值
dict = {}
dict.setdefault("k2")
#相等于
dict["k2"] = "None"
print(dict)

#更新字典
dict = {'k1':'v1','k2':'v2'}
dict.update({'k3':'eric','k4':'alex'})
print(dict)

list 

"""
list内部功能
"""

#列表尾部添加内容
li = []
li.append("aaaaaa")
print(li)

#列表清空
li = ["a","b"]
li.clear()
print(li)

#浅拷贝（只拷贝第一层）
li = ["a","b"]
a_li = li.copy()
print(a_li)

#深拷贝（完整拷贝）
import copy
li = ["a","b"]
a_li = copy.deepcopy(li)
print(a_li)

#统计字符
li = ["a","b","a","b","c"]
result = li.count("a")
print(result)

#合并列表
aList = [123, 'xyz', 'zara', 'abc', 123]
bList = [2009, 'manni']
aList.extend(bList)
print(aList)

#按索引位置插入字符
li = ["a","b","a","b","c"]
li.insert(0,"eric")
print(li)

#默认移除最后一个元素(pop(1)可删除指定索引下标位置的内容)
li = ["a","b","a","b","c"]
li.pop()
print(li)

#移除第一个指定元素
li = ["a","b","a","b","c"]
li.remove("a")
print(li)

#反转
li = ["a","b","a","b","c"]
li.reverse()
print(li)

tuple 

#coding:utf-8
"""
tuple内部功能
"""

#统计元组中的元素
tup = (1,2,3,4,1,1,2,4)
result = tup.count(1)
print(result)

#获取元组中指定元素的索引下标位置
tup = (1,2,3,4,1,1,2,4)
result = tup.index(4)
print(result)

set

#coding:utf-8
'''
集合内部功能
'''

#添加元素
s1 = set()
s1.add('alex')
s1.add('eric')
print(s1)

#清除数据
s1 = set()
s1.add('alex')
s1.add('eric')
s1.clear() 
print(s1)

#set会自动去重
s1 = set(['alex','eric','lisa','tim','alex'])
print(s1)   #{'alex','eric','lisa','tim'}

#浅copy
s1 = set()
s1.add('alex')
s2 = s1.copy()
print(s2)

#深copy
import copy
s1 = set()
s1.add('alex')
s2 = copy.copy(s1)
print(s2)


#随机移除一个数据(可用变量接收被移除的数据)
s1 = set(['alex','eric','lisa','tim'])
s2 = s1.pop()
print("s1：%s 
s2：%s"%(s1,s2))

#指定一个移除的数据(返回修改原来set)
s1 = set(['alex','eric','lisa','tim'])
s1.remove("alex")
print(s1)

#取差集，第一个set对比第二个set是否有重复数据，返回一个新的set对象
s1 = set(['alex','eric','lisa','tim','alex'])
s2 = s1.difference(['alex','eric'])
print(s1)
print(s2)

#取差集修改操作，返回修改原来set
s1 = set(['alex','eric','lisa','tim','alex'])
s1.difference_update(['alex','eric'])
print(s1)

#差集，比较两个set中共同不相同的数据(返回一个新的set)
s1 = set(['alex','eric','lisa','tim','alex'])
s2 = set(['alex','eric'])
result = s1.symmetric_difference(s2)  #{'lisa', 'tim'}
print(result)

#取交集(获取两个set中重复的数据)，并创建一个新的set
s1 = set(['alex','eric','lisa','tim','alex'])
s2 = set(['alex','eric'])
result = s1.intersection(s2)
print(result)   #{'alex', 'eric'}

#取交集修改操作(获取两个set中重复的数据),修改原来set
s1 = set(['alex','eric','lisa','tim','alex'])
s2 = set(['alex','eric'])
s1.intersection_update(s2)
print(s1)   #{'alex', 'eric'}

#判断两个set是否有交集，有返回False，没有True
s1 = set(['alex','eric','lisa','tim','alex'])
s2 = set(['alex','eric'])
print(s1.isdisjoint(s2))
print(s1)

counter

#coding:utf-8
'''
计数器
'''


#Counter是对字典类型的补充，用于追踪值的出现次数（具备dict所有功能和自己的功能）
import collections

#统计各字符出现的次数
obj = collections.Counter("sdflsjdlfksd")
print(obj)
print(obj)  #Counter({'s': 3, 'd': 3, 'f': 2, 'l': 2, 'k': 1, 'j': 1})

#获取计数器的前几(4)位内容
ret = obj.most_common(4)
print(ret)

#获取计数器的值(因为它是collections.Counter类型无法直接取值)
print(type(obj))
#利用items获取key,valu
for k,v in obj.items():
    print(k,v)
#利用elements获取所有元素
for i in obj.elements():
    print(i)

#增加数据,然后统计
obj = collections.Counter([11,22,33])
print(obj)
obj.update(['tim',11,22])
print(obj)

#删除数据，然后统计
obj.subtract(['tim',11,22])
print(obj)

orderedDict

#coding:utf-8
'''
有序字典

说明：
有序字典类似于把dict的key放到list里面(因list是有序的)
循环list，有序把值取出来，在对应dict的key取vlaus

dict = {'k1':'v1','k2':'v2'...}
list = [k1,k2...]
for k in list:
    print(dict[k])
'''

from collections import OrderedDict

#创建有序字典
dic = OrderedDict()
dic["k1"] = "v1"
dic["k2"] = "v2"
dic["k3"] = "v3"
print(dic)


#指定key删除（pop有返回值）
result = dic.pop("k1")
print(dic)
print(result)

#删除退后一项
dic.popitem()
print(dic)


#设置OrderedDict默认值("k4","valu可以不指定为None")
dic.setdefault("k4","v4")
print(dic)

#增加数据（传入一个新dict,增加到原来OrderedDict里面）
dic.update({"k5":"v5"})
print(dic)

#把某一个key放到OrderedDict最后面
dic.move_to_end("k3")
print(dic)

defaultdict

#coding:utf-8
'''
默认字典

如果没有默认字典，需要自己定义一个value的默认类型为list的字典：
dic = {"name":[]}
dic["name"].append("alex")
dic["name"].append("eric")
print(dic)

下面通过collections.defaultdict()快速创建默认字典类型
'''

import collections
#类型为list
dic = collections.defaultdict(list)
dic["name"].append("alex")
dic["name"].append("eric")
print(dic)  #defaultdict(<class 'list'>, {'name': ['alex', 'eric']})

from collections import defaultdict
li = [11,22,33,44,55,66,77,88,99,90]
dic = defaultdict(list)
for n in li:
    if n >66:
        dic["k1"].append(n)
    elif n <= 66:
        dic['k2'].append(n)
print(dic)

namedtuple

#coding:utf-8
'''
可命名元祖

根据nametuple可以创建一个包含tuple所有功能以及其他功能的类型
类似给元组value创建一个别名
'''

import collections

#创建类
MytupleClass = collections.namedtuple("MytupleClass",{'x','y','z'})
print(MytupleClass)
#创建类属性的别名
obj = MytupleClass(11,22,33)
print(obj.x)
print(obj.y)
print(obj.z)

#可查看这个类的方法属性
print(help(MytupleClass))

deque

#coding:utf-8
'''
双向队列

说明：
类似于RabbitMQ的消息队列
'''

import collections

#创建一个双向队列
d = collections.deque()
print(d)

#往队列最后面添加一个value
d.append('pp')
d.append('aa')
d.append({1:111})
print(d)

#往队列最左边添加一个value
d.appendleft('aa')
print(d)

#清空这个队列
d.clear()
print(d)

#队列计数器（统计”aa“有多少个）
count = d.count('aa')
print(count)

#右扩展（在队列的右边添加多个元素）
d.extend(['bb','cc','dd'])
print(d)
#d.extend({2:222})   #拓展不要添加字典（只会把字典key加入拓展，而value不会加入）

#左拓展（在队列的左边添加多个元素）
d.extendleft([1,2,3])
print(d)

#取一个值的索引位置（有多个值，按照从左到右显示第一个）
print(d.index("aa"))

#在某位置插入值
d.insert(2,"insert")
print(d)

#移除一个value（从右边开始）
result = d.pop()
print(d)
print(result)

#移除一个value（从左边开始）
result = d.popleft()
print(d)
print(result)

#移除某些指定的value（如果有重复的值，按照从左到右的顺序移除）
d.remove("insert")
d.remove("aa")
print(d)

#反转排列顺序
d.reverse()
print(d)

#转圈圈，把最后value放到最前（可指定需要把多少个value旋转到最前面）
d.rotate(2)
print(d)

queue.queue

#coding:utf-8
'''
单向队列

说明：
类似于RabbitMQ的消息队列
'''

import queue

#创建单向队列
q = queue.Queue()


#插入一条数据
q.put("123")
q.put("456")

#查看队列个数
print(q.qsize())

#取一条数据
print(q.get())

copy

#coding:utf-8

import copy

#浅拷贝
#copy.copy()
#深拷贝
#copy.deepcopy()



# 浅拷贝：只复制最外面一层
dic = {
    "cpu":[80],
    "mcm":[80],
    "disk":[80]
       }

print("brefor %s"%dic)
new_dic = copy.copy(dic)
dic["cpu"][0] = 50
print(dic)
print(new_dic)


# 深拷贝：新开辟一个内存存储复制的内容，和原来的数据互不影响
dic = {
    "cpu":[80],
    "mcm":[80],
    "disk":[80]
       }

print("brefor %s"%dic)
new_dic = copy.copy(dic)
#new_dic["cpu"][0] = 50
dic["cpu"][0] = 50
print(dic)
print(new_dic)