python数据类型

Python3 中有六个标准的数据类型（对象类型）：
Number（数字）String（字符串）List（列表）Tuple（元组）Sets（集合）Dictionary（字典）
不可变数据（四个）：Number（数字）、String（字符串）、Tuple（元组）、Sets（集合）-frozenset(不可变)；
可变数据（两个）：List（列表）、Dictionary（字典）、Sets（集合）-set（可变集合）

数字：加，减，乘，除，求整，求余，求幂，布尔运算，复数运算
整数类型：0，1，-1，123456
浮点数：1.23，-1.23，12.3e-2，12.3e+2(12.3乘10的2次方)
进制数据：0b1010,0B1010(二进制0b或者0B) 0o127,0O127(八进制0o或者0O) 0x12ef,0X12ef(十六进制0x或者0X)
复数：1.23+1.0j,34-4j complex(a,b)创造复数a为实部b为虚部

a=12.3#浮点数
b=0b1010#二进制数据
c=12.3+5.0j#复数
d=12#整数
print(type(a),type(b),type(c),type(d),print(hex(d),oct(d),bin(d)))#数据类型判断及10进制转换16，8，2
print(int("0b1",2),int("0o7",8),int("0xf",16),int(2.5),int("3"))#内置函数2，8，16转化为10进制及浮点数字符串的整数化
print(float(3),float("2.5"))#内置函数实现整数或者字符串的浮点数化
print(pow(3,3),abs(-23),round(3.67))#内置函数实现幂运算、模运算、四舍五入运算
a,b=3.12,4
print(a+b,a-b,a*b,a/b,7//2,a%b,a**b,a>b,a>b and b< a ,a>b or b< a ,1.1e+2,1.1e+2j,1.2+2j,True+False)

D:\py\venv\Scripts\python.exe D:/py/test.py
0xc 0o14 0b1100
<class 'float'> <class 'int'> <class 'complex'> <class 'int'> None
1 7 15 2 3
3.0 2.5
27 23 4
7.12 -0.8799999999999999 12.48 0.78 3 3.12 94.75854336000002 False False False 110.0 110j (1.2+2j) 1

字符串：长度，索引，切片，拼接，重复，查找，替换，分解子串，大小写转换，判断类型，右端去空和换行符，格式化输出

str="py-learning-";str1="123456";str2="123456  \n\n\n"#\n不在字符串长度内
print("str为:",len(str)," ","str长度为:",str);print(r"123\n\n\\4")#r去除换行符
print(str[0],"",str[1],"",str[-len(str)],"",str[1-len(str)])#正向0开始-反向-1开始,边界检查不可越界否则报错
print(str[0:1],"",str[0:2],"",str[-3:-1],"",str[-3:],"",str[0:],"",str[:])#正向0开始-反向-1开始,不包括后标
print(str+"time",str*3)#字符串拼接用+，重复用*
str="Linux"+str[2:];print(str)#不可改变性不能str[0]="L"这样赋值操作,可通过切片加拼接实现对同名变量赋值
print(str.find("lea"),"",str.replace("Linux","py"),str)#字符串对象函数也不可以改变原始变量
str=str.replace("Linux","py");print(str)#只能通过函数做重新赋值操作，这个str不是之前的str,对象吗？哈哈
print(str.split('-'),str.upper(),str1.isalnum(),str2.rstrip())#分解字串，大小写转换，判断类型，右端去空和换行符
print("%s learning %s"%("py","time"),"","{0} learning {1}".format("py","time"))#格式化字符串
#print(help(str.replace))#查看字符串的某个方法用法或者help(str.replace)

D:\py\venv\Scripts\python.exe D:/py/test.py
str为: 12   str长度为: py-learning-
123\n\n\\4
p  y  p  y
p  py  ng  ng-  py-learning-  py-learning-
py-learning-time py-learning-py-learning-py-learning-
Linux-learning-
6  py-learning- Linux-learning-
py-learning-
['py', 'learning', ''] PY-LEARNING- True 123456
py learning time  py learning time

列表：创建，长度，索引，切片，拼接，增删(改变列表),升降序，嵌套

List=[]#空列表创建
L=[0]*5;print(L) #空列表创建
L1=[0 for i in range(5)];print(L1) #空列表创建

L2=[]
for x in range(3): #空列表创建
    L2.append(0)
print(L2)

L3=[x for x in "test!"]; print(L3)#列表解析创建列表
L4=list("test!"); print(L4)#list创建列表

list=["123",456,12.3,'myist']#单一列表
list1=["123",456,["12",34,56.6,"add"],12.3,'myist']#嵌套多种类型
list2=[[12,34,56],[67,89,90],[12.3,45.6,78.9]]#嵌套列表组成多维矩阵
print(len(list),list[0],list[-1])#索引同理str,边界检查不可越界否则报错
print(list[1:3],list[-4:-1],list[:-1],list[0:],list[:])#切片同理str
print(list+list,"",list*2)#拼接+，重复*，同理str
list.insert(2,"test"),list.append("end"),list.pop(2);print(list)#增加删除改变列表
#list.sort();print(list)#列表数字字符串混合不可排序否则出错
buff=["py","learning","time"];buff.sort(),print(buff),buff.reverse(),print(buff)
buff1=[12,67,34,21];buff1.sort(),print(buff1),buff1.reverse(),print(buff1)
print(list1[0],list1[1],list1[2][0])#嵌套遍历不可对数字或者字符串使用[][]
test=[i[1]for i in list2];test1=[i[0]+2 for i in list2];print(test,test1)#i为变量代指列表中的元素
test=[list2[i][i] for i in [0,1,2]];print(test)#i为遍历列表元素的矩阵的位置
test=[12,"test",34.2,(12,"test",34.2),56]
test[3]=(1,2,3);print(test);test[3]=666;print(test)#列表可整体修改元组但不可以单个修改，元组不可修改性？

D:\py\venv\Scripts\python.exe D:/py/test.py
[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]
[0, 0, 0]
['t', 'e', 's', 't', '!']
['t', 'e', 's', 't', '!']
4 123 myist
[456, 12.3] ['123', 456, 12.3] ['123', 456, 12.3] ['123', 456, 12.3, 'myist'] ['123', 456, 12.3, 'myist']
['123', 456, 12.3, 'myist', '123', 456, 12.3, 'myist']  ['123', 456, 12.3, 'myist', '123', 456, 12.3, 'myist']
['123', 456, 12.3, 'myist', 'end']
['learning', 'py', 'time']
['time', 'py', 'learning']
[12, 21, 34, 67]
[67, 34, 21, 12]
123 456 12
[34, 89, 45.6] [14, 69, 14.3]
[12, 89, 78.9]
[12, 'test', 34.2, (1, 2, 3), 56]
[12, 'test', 34.2, 666, 56]

元组：创建，长度，索引，切片，拼接，嵌套

T3=();L=len(T3);print(L)#空元组
T=tuple("test!");print(T)#tuple函数转化字符串创建
T1=tuple(["t","e","s","t","!"]);print(T1)#tuple函数转化列表创建
T2=tuple(x*2 for x in T1);print(T2)#tuple函数通过解析创建tuple不可去掉与列表不同()会被认为成表达式
tuple=(12,23,23,[1,"X",2],(1,2,"X"));tuple1=(1,2,"x");#直接创建
print(len(tuple),tuple[0],tuple[-1],tuple[0:2],tuple[-3:-1],tuple[:]);#长度，索引，切片同str与list
print(tuple+tuple1,tuple*2);#拼接用+，重复用*
print(tuple.index([1,"X",2]),tuple.count(23))#位置及计数
tuple[3][0]=111;print(tuple);#不可整体改变列表，只可单个改变。元组不可修改性？整体改变相当于替换对象了？

D:\py\venv\Scripts\python.exe D:/py/test.py
0
('t', 'e', 's', 't', '!')
('t', 'e', 's', 't', '!')
('tt', 'ee', 'ss', 'tt', '!!')
5 12 (1, 2, 'X') (12, 23) (23, [1, 'X', 2]) (12, 23, 23, [1, 'X', 2], (1, 2, 'X'))
(12, 23, 23, [1, 'X', 2], (1, 2, 'X'), 1, 2, 'x') (12, 23, 23, [1, 'X', 2], (1, 2, 'X'), 12, 23, 23, [1, 'X', 2], (1, 2, 'X'))
3 2
(12, 23, 23, [111, 'X', 2], (1, 2, 'X'))

集合：无序 不重复性 不可变（元素）--成员只能是字符串元组数字，列表字典集合均不可以
可变与不可变这里指的是可增加和删除元素，与列表可修改元素不一样，它无序不可检索

aa=set()#创造空集合，{}是创造空字典
a={"h","e","l","l",(1,2),1}#直接创建
b=set("ellt")#内置函数set创建
c=frozenset("abcdeff")#内置函数frozenset创建不可变集合
d={i for i in "test"};dd={i*2 for i in "test"}#集合解析创建
e={(x,y) for x in "te" for y in "eest"}#集合解析创建
#ee={{x,y} for x in "te" for y in "eest"}#TypeError: unhashable type: 'set'
#eee={[x,y] for x in "te" for y in "eest"}# TypeError: unhashable type: 'list'

f=set()#等同于上边的集合解析创建
for x in "te":
    for y in "eest":
        f.add(x+y)

print(a,'\n',b,'\n',c,'\n',d,'\n',dd,'\n',e,'\n',f)
#print(len(a),a,b,a|b,a-b,a&b,a^b);print(aa|b);

for i in e :#元素遍历
    print(i,end=" ")#print(type(i))#数据类型判断
print("")

len1=len(a)#返回集合的长度
a1=a.copy()#集合的复制
a1.add(12)#增加元素12，自身不重复性添加重复元素不报错没影响
a1.remove(1)#删除元素1
a1.pop()#随机删除一个元素
a1.discard("h")#删除元素h不存在返回None
a1.intersection(a)#集合a1和a的交集，a1&a
a1.difference(a)#集合a1和a的差集，a1-a
a1.union(a)#集合a1和a的并集，a1|a
a1.symmetric_difference(a)#集合a1和a的非交集的部分，a1^a
if "h" in a:a1.clear()#判断元素是否在集合中及清空集合操作
print(len1,a1)

D:\py\venv\Scripts\python.exe D:/py/test.py
{(1, 2), 1, 'h', 'e', 'l'} 
 {'e', 't', 'l'} 
 frozenset({'d', 'a', 'b', 'f', 'e', 'c'}) 
 {'e', 't', 's'} 
 {'ee', 'tt', 'ss'} 
 {('t', 's'), ('e', 't'), ('t', 'e'), ('e', 'e'), ('e', 's'), ('t', 't')} 
 {'te', 'es', 'ee', 'tt', 'et', 'ts'}
('t', 's') ('e', 't') ('t', 'e') ('e', 'e') ('e', 's') ('t', 't') 
5 set()

 字典：无序  key:value  嵌套(列表和集合和字典) key不可以使用可改变的对象列表

test1={};#空字典
test2=dict(a=1,b=(1,2,"a"),c=[1,2,(1,2)]);print(test2)
#test3=dict{"a":1,"b":2,"c":3}
test={"a":11,"c":{1:2,3:4,"5":6},"d":['a',"b",12,34.5],"b":{"h","e","l","l","o"}};
print(test,"\n",test.keys(),"\n",test.values());#键值和元素获取
#aa=list(test.keys());print(aa)
for i in sorted(test):          #sorted对字典的键值进行排序
    print(i,"=>",test[i]);
test["d"][-1]=666;test["d"].append("888");print(test["d"])
print(test["a"],"",test["c"],"",test["c"][3],"",test["d"][-1])#嵌套任意类型

D:\py\venv\Scripts\python.exe D:/py/test.py
{'a': 1, 'b': (1, 2, 'a'), 'c': [1, 2, (1, 2)]}
{'a': 11, 'c': {1: 2, 3: 4, '5': 6}, 'd': ['a', 'b', 12, 34.5], 'b': {'o', 'h', 'l', 'e'}} 
 dict_keys(['a', 'c', 'd', 'b']) 
 dict_values([11, {1: 2, 3: 4, '5': 6}, ['a', 'b', 12, 34.5], {'o', 'h', 'l', 'e'}])
a => 11
b => {'o', 'h', 'l', 'e'}
c => {1: 2, 3: 4, '5': 6}
d => ['a', 'b', 12, 34.5]
['a', 'b', 12, 666, '888']
11  {1: 2, 3: 4, '5': 6}  4  888