Python保留偶数数字 python中保留整数

一、基本数据类型

1.1、数值类型

1.1.1、int类型，整型不能被遍历

int() # 将字符串转换为整形
int('',base='禁止') # 将元素转化为指定的进制类型输出
元素.bit_length() # 数值二进制表示的位数

1.1.2、浮点类型

# 浮点数截断：有时浮点数太长，我们可能希望截断。一般有2大种截断需求：只保留整数、保留指定位数的小数。

# 只保留整数
# 只保留整数小数全部舍弃
print int(3.8), int(3.1)
# 3 3

# 保留整数并且四舍五入
print round(3.8), round(3.1)
# 4.0 3.0

# 保留整数向上取整
import math
print math.ceil(3.8), math.ceil(3.1)
# 4.0 4.0

# 保留整数向下取整
import math
print math.floor(3.8), math.floor(3.1)
# 3.0 3.0

# 保留小数
# 指定小数位数四舍五入
print round(3.11, 1) , round(3.18, 1)
# 3.1 3.2

# 指定小数2位向下取整
import math
num = 3.1415
num = num*100
print math.floor(num)/100
# 3.14

# 指定小数2位向上取整
import math
num = 3.1415
num = num*100
print math.ceil(num)/100
# 3.15

1.2、str类型，字符串类型

#字符串的相关操作

#基本操作
#+  字符串连接操作
str1 = '来是come走是go'
str2 = '点头yes摇头no'
result = str1 + str2
print(len(str1)) # 获取字符串长度
print(result)

#*  字符串复制操作
str1 = '天地不仁以万物为刍狗'
result = str1 * 3
print(result)

#[]  索引操作
str1 = '柳暗花明又一村'
print(str1[1])
print(str1[-2])

#[::]取片操作
str1 = '山重水复疑无路'
#获取指定范围内的字符串(从开始位置到结束位置之前,不包含结束位置)
result = str1[2:5]
print(result)
#获取开始位置到最后的所有字符串
result = str1[2:]
print(result)
#获取从开头到指定位置之前的所有字符串
result = str1[:5]
print(result)

#获取整个字符串
result = str1[:]
print(result)

#获取字符串时设定索引增加的值 默认1
result = str1[::6]
print(result)


#函数
#capitalize()  首字母大写
str1 = 'fire in the hole'
print(str1)
result = str1.capitalize()
print(result)

#title  每个单词首字母大写
str1 = 'if you lose youself'
print(str1)
result = str1.title()
print(result)

#upper()  所有字母转化为大写
str1 = 'if you feel my love'
print(str1)
result = str1.upper()
print(result)

#lower()  所有字母转化为小写
str1 = 'YOU ARE A LOEWR BEE'
print(str1)
result = str1.lower()
print(result)

#swapcase()  大小写互换
str1 = 'gOOd gooD stUdy'
print(str1)
result = str1.swapcase()
print(result)

#len()  获取字符串的长度
str1 = '明月几时有'
result = len(str1)
print(result)

#count()  统计字符串中指定字符出现的次数
str1 = '人人都说:初恋是用来练手的,但其实单身才是用来练手的'
#result = str1.count('手')
result = str1.count('手',10,22)
print(result)

#find()  查找指定字符在字符串中第一次出现的位置  找到返回索引,找不到返回-1
str1 = '山重水复疑无路,柳暗花明又一村'
#从头查找
#result = str1.find('水')
#从指定位置开始查找
result = str1.find('花',7,12)
print(result)

#index()  查找指定字符在字符中第一次出现的位置  找到返回索引,找不到返回错误
str = 'sagdkhkhdkahkdhkjh'
#从头查找
result = str1.index('z')
#丛指定位置开始查找
result = str1.index('h',5,20)
print(result)
#startwith()  检测字符串是否以指定字符串开头
str1 = '孙悟空头上的箍叫什么?猴头箍'
result = str1.startswith('孙猴子')
print(result)

#endswith()  检测字符串是否以指定字符串结尾
result = str1.endswith('金针箍')
print(result)

#isupper()  检测字符串内容是否都是大写
str1 = 'YOU CAN YOU UP, NO CAN NO BIBI'
result = str1.isupper()
print(result)

#islower()  检测字符串内容是否都是小写
str1 = 'you can you up，no can no bibi'
result = str1.islower()
print(result)

#istitle()  检测字符串是否是每个单词首字母大写
str1 = 'You Hurt My Heart Deeply'
result = str1.istitle()
print(result)

#isalnum()  检测字符串是否由数字和字母组成(汉字当做字母处理)
str1 = '1234567890abcdef'
result = str1.isalnum()
print(result)

#isalpha()  检测字符串是否由字母组成(汉字当做字母处理)
str1 = '哈哈haha'
result = str1.isalpha()
print(result)

#isdigit()  检测是否由纯数字组成的字符串
str1 = '1234567890'
result = str1.isdigit()
print(result)

#isnumeric()  检测是否由纯数字组成的字符串
str1 = '1234567890'
result = str1.isnumeric()
print(result)

#isdecimal()  检测是否由纯数字组成的字符串
str1 = '1234567890'
result = str1.isdecimal()
print(result)

#isspace()  检测字符串是否由空白字符组成
str1 = '\n\r\t'
result = str1.isspace()
print(result)

#split()  将字符串使用特定的字符切割成多个字符串组成的列表
str1 = '似曾-相识-燕归来'
result = str1.split('-')
print(result)

#splitlines()将字符串使用换行符号切割成多个字符串组成的列表
str1 = 'wuke\r\nnaihehua\rluoqu'
result = str1.splitlines()
print(result)

#join() 将一个序列中的内容使用特定的符号链接成一个字符串 split的反向操作
result = '*'.join(result)
print(result)

#zfill()  0填充效果(数据库中数据存储常用)
var = '998'
result = var.zfill(10)
print(result)

#center()  使用指定字符填充字符串,原有内容居中显示
var = 'jzz'
result = var.center(12,'@')
print(result)

#ljust() 使用指定字符填充字符串,原有内容靠左显示
var = 'jzz'
result = var.ljust(11,'@')
print(result)

#rjust()使用指定字符填充字符串,原有内容靠右显示
var = 'jzz'
#result = var.rjust
result = var.rjust(13,'@')
print(result)

#strip()  去掉字符串两侧指定的连续的字符
var = '@@@@迷之走位@@@@'
#result = var.strip('')
result = var.strip('@')
print(result)

#lstrip()  去掉字符串左侧指定的连续的字符
var = '@@@@迷之走位@@@@'
#result = var.lstrip()
result = var.lstrip('@')
print(result)

#rstrip()  去掉字符串右侧指定的连续的字符
var = '@@@@迷之走位@@@@'
#result = var.rstrip()
result = var.rstrip('@')
print(result)

#字符串替换操作
var = '君不见黄河之水天上来'
#制作替换字典
#result = ''.maketrans('君','汝')
result = ''.maketrans('君','汝','水')
print(result)
#替换操作
newvar = var.translate(result)
print(newvar)


#format() 函数 格式化字符串
#基本格式
var = '{}去{}做了{}'
result = var.format('ch','饭店','饭')
print(result)

#带序号的格式
var = '{2}去{1}做了{0}'
result = var.format('ch','饭店','饭')
print(result)

#带名称的格式
var = '{who1}去{where}做了{who2}'
result = var.format(who1 = 'ch',where = '饭店',who2 = '饭')
print(result)

#使用容器格式-列表
var = '{0[2]}去{0[1]}做了{0[2]}'
result = var.format(['ch','饭店','饭'])
print(result)

#限定符号的使用
# < ^ > 填充对齐符号
var = '君不见{:#>10}之水天上来'
result = var.format('黄河')
print(result)

#精度计算
var = '派的值为:{:.3f}'
result = var.format(3.1415926)
print(result)

#进制转换操作  b o x d
var = '体重:{:b}公斤'
result = var.format(70)
print(result)

#金融数字格式
var = '身价:{:,}越南盾'
result = var.format(1123674434.43)
print(result)

#截取字符串
str = ’0123456789′
print str[0:3] #截取第一位到第三位的字符
print str[:] #截取字符串的全部字符
print str[6:] #截取第七个字符到结尾
print str[:-3] #截取从头开始到倒数第三个字符之前
print str[2] #截取第三个字符
print str[-1] #截取倒数第一个字符
print str[::-1] #创造一个与原字符串顺序相反的字符串
print str[-3:-1] #截取倒数第三位与倒数第一位之前的字符
print str[-3:] #截取倒数第三位到结尾
print str[:-5:-3] #逆序截取，具体啥意思没搞明白？

二、集合set()

#集合(无序的一组数据)
#基本操作
#创建集合
#空集合
var = set()
print(var,type(var))

#具有数据的集合
var = {'zhangwang','zhangbo','zhanglang'}
print(var,type(var))

#成员检测
result = 'zhangbo' in var
print(result)

result = 'zhangsan' not in var
print(result)

#集合推导式
var = {'蚂蚱','螳螂','蝈蝈','蛐蛐'}

#基本的集合推导式
result = {'*'+i+'*' for i in var}
print(result)

#带有判断条件的集合推导式
result = {i for i in var if i != '蛐蛐'}
print(result)

#多循环集合推导式
colors = {'red','blue','pink'}
sizes = {36,37,38,39}
result = {c + str(s) for c in colors for s in sizes}
print(result)

#集合函数
'''
#add()  向集合中添加元素
girls = {'mf','sl','yj'}
girls.add('xf')
print(girls)

#pop()  随机删除集合中的一个元素
boys = {'bd','zw','jl','zy'}
result = boys.pop()
print(boys)
print(result)

#remove()  删除集合中指定的元素  删除不存在的元素会报错
boys = {'bd','zw','jl','zy'}
boys.remove('zy')
print(boys)

#discard()  删除集合中指定的元素  删除不存在的元素啥都不做
boys = {'bd','zw','jl','zy'}
boys.discard('zy1')
print(boys)

#clear()  清空集合
boys = {'bd','zw','jl','zy'}
boys.clear()
print(boys)

#copy()  复制集合
boys = {'bd','zw','jl','zy'}
newboys = boys.copy()
print(newboys)
'''

#difference() 计算2个集合的差集
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
result = dreamers.difference(girls)# result = a + b
print(result)

#difference_update()  计算2个集合的差集(差集更新操作)
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
dreamers.difference_update(girls)#a = a + b  a += b
print(dreamers)

#union()  并集操作
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
result = dreamers.union(girls)
print(result)

#update()  并集更新操作
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
dreamers.update(girls)
print(dreamers)

#intersection()  计算2个集合的交集
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
result = dreamers.intersection(girls)
print(result)

#intersection_update  交集更新操作
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
dreamers.intersection_update(girls)
print(dreamers)

#超集和子集
boys = {'zzy','yqw','dw','wzc','lyb','wym','chy'}
zoudu = {'wzc','lyb','wym'}
girls = {'lsy','mmf','syj'}

#issuperset()  检测当前集合是否是另一个集合的超集
result = boys.issuperset(zoudu)
print(result)

#issubset()  检测当前集合是否是另一个集合的子集
result = zoudu.issubset(boys)
print(result)

#isdisjoint()  检测2个集合是否不存在交集  存在交集 False
result = boys.isdisjoint(girls)
print(result)

#symmetric_difference()  对称差集
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
result = dreamers.symmetric_difference(girls)
print(result)

#symmetric_difference_update()  对称更新差集
dreamers = {'ljl','wc','xy','zb','lsy'}
girls = {'mmf','lsy','syj'}
dreamers.symmetric_difference_update(girls)
print(dreamers)

#冰冻集合
#冰冻集合是一种特殊的集合类型,也是集合(集合是列表的话,冰冻集合就是元组)
#创建冰冻集合
#一般不会创建空的冰冻集合
var = frozenset()
print(var,type(var))

#带有数据的冰冻集合
var = frozenset(('qs','szx','bjh','acs'))
print(var,type(var))

#成员检测
result = 'szx' in var
print(result)

#遍历冰冻集合
for i in var:
    print(i)

#集合推导式(无法得到冰冻集合,可以得到集合,列表,元组,字典类型)
result = {i for i in var}
print(result,type(result))

#函数
#冰冻集合可以使用集合的函数(不修改集合本身的函数都可以使用)
var = frozenset(('qs','szx','bjh','acs'))

#copy()
result = var.copy()
print(result)

#集合操作  交集,并集,差集,对称差集等  不修改冰冻集合本身就能使用:冰冻集合的操作结果都是冰冻集合
var1 = frozenset(('qs','szx','bjh','acs'))
var2 = {'szx','bjh','lc','wb'}

#冰冻集合操作
result = var1.union(var2)
print(result)

#普通集合操作(冰冻集合是参考集合)
result = var2.union(var1)
print(result)

三、字典的操作dict()

#字典类型
#创建字典
#空字典
var = dict()
print(var,type(var))

var = {}
print(var,type(var))

#创建具有多个数据的字典
#1.
var = {'黑':'black','白':'white','蓝':'blue'}
print(var,type(var))
#2.
var = dict({'黑':'black','白':'white','蓝':'blue'})
print(var,type(var))
#3.
var = dict(黑 = 'black',白 = 'white',蓝 = 'blue')
print(var,type(var))
#4.
var = [
    ['黑','black'],
    ['白','white'],
    ['蓝','blue']
]
result = dict(var)
print(result,type(result))
#5.
keys = ['黑','白','蓝']
values = ['black','white','blue']
result = dict(zip(keys,values))
print(result,type(result))

#元素 -> 键值对 -> 键+值
#基本操作
var = {'赵云':'子龙','庞统':'士元','郭嘉':'奉孝','鲁肃':'子敬'}
#访问字典:
print(var['赵云'])

#修改字典
var['郭嘉'] = '天妒'
print(var)

#删除元素
del var['郭嘉']
print(var)

#添加元素
var['周瑜'] = '公瑾'
print(var)

#序列操作
#成员检测 ->针对于键的操作而不是值
var = {'赵云':'子龙','庞统':'士元','郭嘉':'奉孝','鲁肃':'子敬'}
result = '士元' in var
print(result)

#len()  检测字典中元素的个数
var =  {'赵云':'子龙','庞统':'士元','郭嘉':'奉孝','鲁肃':'子敬'}
result = len(var)
print(result)

#max()  获取字典中最大的键如果不是数字键 获取最大编码的值
var = {'a':1,'b':2,'c':3,'晷':12}
result = max(var)
print(result)

#min() 获取字典中最小的键如果不是数字键 获取最小编码的值
var = {'a':1,'b':2,'c':3,'晷':12}
result = min(var)
print(result)

#字典的遍历
var = {'赵云':'子龙','庞统':'士元','郭嘉':'奉孝','鲁肃':'子敬'}

#方法1:先遍历键,再使用变量和键来获取对应的值
for i in var:
    print(i,var[i])

#方法2:同时遍历键和值
result = var.items()
print(result,type(result))#不是标准的列表类型
for k,v in var.items():
    print(k,v)

#字典推导式
var = {'ag':'sfsf','bg':'fsdf','cg':'df'}

#普通推导式
result = {k:v for k,v in var.items()}
print(result)

#带有判断条件的推导式
result = { k:v for k,v in var.items() if len(v) == 2}
print(result)

#多循环的字典推导式
girls= {'zb':'bo','mm':'mei','jj':'jun'}
boys = {'ll':'le','ff':'fei','ji':'jiao'}

result = { g+b:gv +bv for g,gv in girls.items() for b,bv in boys.items()}
print(result)

#字典相关函数
var = {'孙行者':'孙悟空','沙和尚':'沙悟净','猪八戒':'猪悟能'}
#clear 清空字典
var.clear()
print(var,id(var))

#copy() 复制字典
newvar = var.copy()
print(newvar,id(newvar))

#fromkeys()  使用序列(键)和指定的值(值)制作一个字典
list = ['fda','fsd','jgj','hfg']
result = dict.fromkeys(list,'小鸟')
result = {}.fromkeys(list,'小鸟')
print(result)

#get()  获取字典中指定键的值
result = var.get('猪八戒','默认值')#result =var['猪八戒']
print(result)

#setdefault()  向字典中添加一个元素[不存在的键则添加,存在的键不做任何操作]
var.setdefault('小白龙','小白龙')
print(var)

#update()  修改字典中的元素
var.update(孙行者 = '孙猴子')
print(var)

var.update({'孙行者':'齐天大圣','猪八戒':'天蓬元帅','唐僧':'唐玄奘'})
print(var)

#pop()  删除字典中指定的元素
result = var.pop('唐僧')
print(var)
print(result)

#popitem()  随机删除字典中的一个元素
result = var.popitem()
print(var)
print(result)

#keys()  获取字典中的所有键组成的容器
var = {'苹果':'Apple','梨':'pear'}
result = var.keys()
print(result)
for i in result:
    print(i)

#values()  获取字典中的所以值组成的容器
result = var.values()
print(result)

#items()  获取字典中的所有键和值组成的2级容器
result = var.items()
print(result)

四、列表list()

#列表(一组有序数据的组合就是列表)

#创建列表
#空列表
var = list()#var = []
print(var,type(var))

#具有多个元素的列表
var = ['风','水','风水']
print(var,type(var))

#基本操作
var = ['地','火','地火']
#访问列表中的元素
print(var[-2])

#修改元素
var[1] = '水'
print(var)

#删除元素
del var[1]
print(var)

#添加元素(不能加)

#序列操作
listvar1 = ['胡一菲','曾小贤','陆展博']
listvar2 = ['林宛瑜','陈美嘉','吕子乔','关谷神奇']

#相加
result = listvar1 + listvar2
print(result)

#相乘操作
result = listvar1 * 2
print(result)

#分片
#result = listvar2[:3]
#result = listvar2[1:]
#result = listvar2[1:3]
#result = listvar2[:]
#print(result)

#成员检测
result = 'Lisa荣' in listvar2
print(result)

result = 'Lisa荣' not in listvar2
print(result)

#序列函数
#len() 检测列表中元素的个数
var = ['张三','李四','王五','赵六']
result = len(var)
print(result)

#max() 获取最大值
result = max([12,23,34,45,21,32,43,54])
print(result)

#min() 获取最小值
result = min([12,23,34,45,21,32,43,54])
print(result)

#遍历列表

#for...in
var = ['红','橙','黄','绿','青','蓝','紫']
for i in var:
    print(i)

#while遍历
i = 0
while i < len(var):
    print(var[i])
    i += 1

#多层列表的遍历
var = [
    ['小黑','black'],
    ['小白','white'],
    ['小彩','color']
]

#等长二级列表
for i,j in var:
    print(i,j)

#等长或不等长列表都可以遍历
for i in var:
    #print(i)
    for j in i:
        print(j)

#列表推导式
var = ['段誉','虚竹','乔峰','木婉清','钟灵儿']
#最基本的列表推导式
result = ['@'+i+'@' for i in var]
print(result)

#书写列表1-10,使用列表推导式获取当前列表中每个数字*3的列表
var = [1,2,3,4,5,6,7,8,9,10]
result = [i * 3 for i in var]
print(result)

#带有判断条件的列表推导式
var = [1,2,3,4,5,6,7,8,9,10]
result = [a for a in var if a % 2 == 0]
print(result)

#声明一个多人名称的列表,使用推导式获取所有三个字人名
var = ['段誉','虚竹','乔峰','木婉清','钟灵儿']
result = [n for n in var if len(n) == 3]
print(result)

#多循环列表推导式
sizes = [37,38,39,40,41]
colors = ['yellow','cyan','pink','purple']
result = [str(s) +'-'+ c for s in sizes for c in colors]
print(result)

#男组4人,女组5人,互相见面一次
men = ['男1','男2','男3','男4']
women = ['女1','女2','女3','女4','女5']
result = [m +'-'+ w for m in men for w in women]
print(result)

#带有判断条件的多循环列表推导式
men = ['男1','男2','男3','男4']
women = ['女1','女2','女3','女4']
result = [m +'-'+ w for m in men for w in women if men.index(m) == women.index(w)]
print(result)


#append()  向列表的末尾添加元素  直接修改元列表
var = ['a','b','c','d']
print(var)
var.append('e')
print(var)

#insert() 在列表的指定位置之前添加元素
var = ['a','b','c','d']
print(var)
var.insert(2,'g')
print(var)

#pop()  删除列表中指定位置的元素
var = ['a','b','c','d']
print(var)
result = var.pop(0)
print(var,result)

#remove()  删除列表中指定值的元素
var = ['a','b','c','d']
print(var)
result = var.remove('c')
print(var,result)

#clear()  清空列表
var = ['a','b','c']
print(var,id(var))
var.clear()
print(var,id(var))

#copy()  复制列表
var = ['a','b','c','d']
print(var,id(var))
newvar = var.copy()
print(newvar,id(newvar))

#count() 计算列表中某个元素出现的次数
var = [2,3,4,3,4,5,6,7,8,5,4,6,7,8]
result = var.count(5)
print(result)

#excend() 将一个列表合并到另外一个列表中
var1 = ['xs','dc','yyh','wzj']
var2 = ['dsn','lss','cyy','lrs']
var1.extend(var2)
print(var1)

#index() 获取某个元素在列表中的索引
var = ['xs','dc','yyh','wzj']
result = var.index('dc')
print(result)

#reverse() 列表反转操作
var = ['a','b','c','d']
print(var)
var.reverse()
print(var)

#sort() 排序函数
var = [23,342,34,32,75,59]

#默认排序  升序
#var.sort()
#print(var)

#降序
#var.sort(reverse=True)
#print(var)

#自定义排序规则
#奇偶数
def myfunc(num):
    result = num % 5
    return result
var.sort(key=myfunc,reverse = True)
print(var)

a = [4,5,66,45,99]
 #   0 1 0 1 1
 #   1 0 1 0 0
#a.sort(key=ceshi,reverse=False)
a.sort(key = lambda x:x%2==0)
#print(a)

def ceshi(x):
    return x%2 == 0
a.sort(key=ceshi)
print(a)

#sort 排序按照返回值来排 特点基于原来列表进行排序
'''
> < >= <= != ==

true 1  false 0

True + 1 1+1
1 + 1.1 2.1

bool  int  float
float()
int()
bool()
'''

五、元祖tuple()

#元组(元组也是一组有序数据的组合，和列表唯一的不同是，元组不可修改)
#创建单个元素的元组
#var = (13,)
var = 23,
print(var,type(var))

#元组只能进行访问操作
var = ('yy','bb','dlrb','glnz')
print(var[1])
print(var[-2])

#元组的序列操作
# +
var1 = (1,3,5,7,9)
var2 = (2,4,6,8,10)
result = var1 + var2
print(result)

#列表或者元组具有很多层
girls = (
    (
        ('小赵','小钱'),
        ('小李','小周')
    ),
    (
        ('小吴','小郑'),
        ('小王','小刘')
    )
)
#访问多层元组中的内容
print(girls[1])
print(girls[1][1])
print(girls[1][1][0])

#元组推导式->生成器->不要则不给
var = (1,2,3,4,5,6,7,8,9)
result = (i * 2 for i in var)
print(result)#结果为生成器
for a in result:
    print(a)

六、python json 字符串模块

'''
json，用于字符串 和 python数据类型间进行转换

Json模块提供了四个功能：dumps、dump、loads、load
'''
import json
# loads 内部必须是双引号
str1 = '[7,1,2,3,4,5,6]'  # 这是一个格式类似列表的字符串
print(type(str1))
list_str = json.loads(str1,encoding="utf-8")  # 使用loads方法格式化字符串，转换格式为它类似的python类型
print(list_str, type(list_str))
'''
运行结果
<class 'str'>
[7, 1, 2, 3, 4, 5, 6] <class 'list'>
'''


dic = {"a":123, "c":552, "b":234}  # 这是一个元组
print(type(dic))
str_dic = json.dumps(dic, sort_keys=True, indent=4)  # 使用dumps方法格式化元组，转换为所有语言都能识别的字符串
print(str_dic, type(str_dic))
'''
运行结果
<class 'dict'>
{
    "a": 123,
    "b": 234,
    "c": 552
} <class 'str'>
'''

七、Byets 数据类型 byets()

在Python3以后，字符串和bytes类型彻底分开了。字符串是以字符为单位进行处理的，bytes类型是以字节为单位处理的。

bytes数据类型在所有的操作和使用甚至内置方法上和字符串数据类型基本一样，也是不可变的序列对象。

bytes对象只负责以二进制字节序列的形式记录所需记录的对象，至于该对象到底表示什么（比如到底是什么字符）则由相应的编码格式解码所决定。Python3中，bytes通常用于网络数据传输、二进制图片和文件的保存等等。可以通过调用bytes()生成bytes实例，其值形式为 b'xxxxx'，其中 'xxxxx' 为一至多个转义的十六进制字符串（单个 x 的形式为：\x12，其中\x为小写的十六进制转义字符，12为二位十六进制数）组成的序列，每个十六进制数代表一个字节（八位二进制数，取值范围0-255），对于同一个字符串如果采用不同的编码方式生成bytes对象，就会形成不同的值。

b = b''         # 创建一个空的bytes
b = byte()      # 创建一个空的bytes
b = b'hello'    #  直接指定这个hello是bytes类型
b = bytes('string',encoding='编码类型')  # 利用内置bytes方法，将字符串转换为指定编码的bytes
b = str.encode('编码类型')   # 利用字符串的encode方法编码成bytes，默认为utf-8类型

bytes.decode('编码类型') # 将bytes对象解码成字符串，默认使用utf-8进行解码。

对于bytes，我们只要知道在Python3中某些场合下强制使用，以及它和字符串类型之间的互相转换，其它的基本照抄字符串。

简单的省事模式：

string = b'xxxxxx'.decode()

b = string.encode()

七、python隐藏变量

__doc__  # 表示本文件的注释
__file__ # 表示本文件的路径  
__package__ # 导入的py文件所在的文件夹路径
__cached__ # 导入文件的缓存
__name__  #如果是主文件 __name__ = "__main__" 否则等于函数名称

八、判断数据内容方法

8.1、isinstance(参数1,参数2)

描述：该函数用来判断一个变量（参数1）是否是已知的变量类型(参数2) 类似于type()

参数1：变量

参数2：可以是直接或间接类名、基本类型或者由它们组成的元组。

返回值: 如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False

8.2、isinstance() 与 type() 区别：

• type() 不会认为子类是一种父类类型，不考虑继承关系。
• isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。