一、基本數據類型
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() 直接以默認的utf-8編碼解碼bytes成string
b = string.encode() 直接以默認的utf-8編碼string爲bytes
七、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()。