数据类型分类
一：可变不可变
可变：列表，字典
不可变：数字，字符串，元组
二：存放值的个数
一个值：数字，字符串
多个值(容器类型)：列表，元组，字典
三：取值方式
直接取值：数字
序列类型：字符串，元组，列表
映射类型：字典
可变或者不可变的定义:在id和type不变的情况下,值可变的数据是可变类型.id,type,value都不可变的是不可变类型
一、列表
特性:list中的元素可以随意删除增加且list的id和type不会改变,ist是一种可变类型.列表中的所有元素可以是 int 可以是 str 也可以是list(子列表).list中的值是有序的.
定义列表：l=[11,22,33,44,55,66]
取值：通过索引
print(l[1])
循环:
l=[1,2,3,[4,5]] c=len(l) for i in range(c): z=l[i] if type(z) is list:
#z是列表，z=[4,5] for j in range(len(z)): print(z[j]) else:
#z不是列表，直接打印 print(z)
列表的常用操作
切片
l=[11,22,33,44,55,66]
print(l[1:5])
追加
l.append() 向后追加元素
插入
l.insert（1，‘SB’） 在指定索引的位置插入值
删除
l.pop() 移除最后一个值 a=.pop() 在原列表中移除掉最后一个元素并赋值给a
显示索引位置
l.index（） 获取指定元素的索引位置
包含
print(11 in l)
其他
.count（） 查看有元素出现的次数
.extend（） 批量添加元素
.remove（） 移除某个元素
.reverse（） 把所有元素顺序倒过来，反转
.sort（） 排序
del 列表名[1] 删除索引指向的元素
#字符串——>数字 int（字符串）
二、元组
特性:元组内的所有元素不能更改,元素可以是任意数据类型
元组中可以包含list,元组中的list中的元素是可以更改的.当然list中也可以有元组.
定义元组
name_tuple = ('alex','eric')
索引
print（name_tuple[0]）
len
print（name_tuple[len(name_tuple)-1]）
切片
print（name_tuple[0:1]）
for
for i in name_tuple:
print(i)
count：计算元素出现的个数
print（name_tupel.count('alex')）
index：获取指定元素的索引位置
print（name_tupel.index('alex')）
三、字典
{花括号} dict 可变类型，key不可变，value可变
字典定义的基本形式：key：value
定义字典需要注意：key必须是不可变类型，或者说是可hash类型
字典的取值，字典是无序的，不可用索引
字典的取值需要打印key
#字典的常用方法 #定义字典 d={'x':1,'y':12222} #长度 len(d) #新增 d['x']=2 print(d) #遍历 print(d.items()) for item in d.items(): #[('x', 1), ('y', 12222)] print(item) #以元组的形式取出键值对 for k,v in d.items(): #解压键值对 print(k,v) print（d.keys()） # 获取所有的key print（d.values()） # 获取所有的values print（d.itmes（）） #获取所有的元素 查找 print(d.get('y')) print(d.get('y','找不到')) print(d.get('e','找不到')) 删除键值对 d.pop('x') print(d) 随机删除键值对 print(d.popitem()) print(d) 清除元素 d.clear() print(d) #快速产生字典 d1={} d2=dict() d3=dict(x=1,y=2,z=3) d4=dict({'x':1,'y':2,'z':3}) d5=dict([('x',1),('y',2),('z',3)]) d6={}.fromkeys(['name','age'],None) #把key的值都设置成None，用于创建初始的字典 print(d1,d2,d3,d4,d5,d6) #更新字典元素,覆盖 d={'name':'alex'} d1={'name':'alexsb','age':50} d.update(d1) print(d)
d.clera（） #清楚所有内容
get 根据key获取值，如果key不存在，可以指定一个默认值
val = d.get('x') #获取age的对应值
val = d.get('age111','123') #获取age111的对应值，如果没有，默认就把123定义为val的值
索引取值时，key不存在报错
print（‘age’in info） #判断age是否存在于字典info
del d[‘x’] #删除字典里的指定元素
enumerate自动生成一列，默认从0开始，可以添加数字指定
四、集合
集合作用一：关系运算 集合作用二：去重 #定义集合： #集合内的元素必须的唯一的 #集合内的元素必须是可hash（不可变）的 #集合是无序的 s={'sam',123,'sam'} print(s,type(s)) #循环 s={'1',1,(1,2),'a'} for i in s: print(i) #关系运算 python_l={'egon','alex','铁蛋','老王'} linux_l={'alex','铁蛋','矮跟','欧德博爱'} #取共同部分：交集 print(python_l & linux_l) # #取老男孩所有报名学生：并集 print(python_l | linux_l) #取只报名了python和只报名了linux的学生：差集 print(python_l - linux_l) print(linux_l - python_l) # #取没有同时报名python和linux的学生：对称差集 print(python_l ^ linux_l) #集合方法 python_l={'egon','alex','铁蛋','老王'} linux_l={'alex','铁蛋','矮跟','欧德博爱'} print(python_l.difference(linux_l))#python -linux print(python_l.intersection(linux_l))#交集 print(python_l.union(linux_l))#并集 print(python_l.symmetric_difference(linux_l))#对称差集 python_l={'egon','alex','铁蛋','老王'} linux_l={'alex','铁蛋','矮跟','欧德博爱'} python_l.difference_update(linux_l) print(python_l) #对称差集并更新 s1={'a',1} s2={'a','b',2} s1.update(s2) print(s1) #把S2的内容更新到S1里 s1={1,2} s2={1,2,3} print(s1.issubset(s2))#子集 print(s2.issuperset(s1))#父集 s1={'a',1} s1.add(1) print(s1) #添加元素，元素存在不修改 s1.discard('a') #删除元素，元素不存在也不报错 s1.discard('b') print(s1) s1.remove('nnnnnn') #删除元素，元素不存在就报错 print(s1) s1={'a',1,'b','c','d'} print(s1.pop()) #.pop随机删除 print(s1) s1={1,2,'a'} s2={1,2,3} print(s1.intersection(s2)) #判断是否有交集，有则返回值 print(s1.isdisjoint(s2)) #判断是否没有交集，有则返回False s1={'a','b'} s2={'c','d'} print(s1.isdisjoint(s2)) #没有交集返回True
五、补充
变量的组成：变量名，赋值符号，变量值
在Python中数据又称为对象,每创建一个对象都会创建对象的id,type,值.
比较方法：
身份比较：is 比较的是变量值的id
值比较：== 比较变量的值
类型比较：type 比较变量的类型
变量的赋值：
链式赋值
a=b=c=d=1
多元赋值
xy的值互换
x = 1
y = 2
方法一：
z = x
x = y
y = z
方法二：
python中: x,y=y,x
增量赋值
x=1
x+=1
x-=1
x*=1
x/=1
解压序列类型:
s = 'hello'
a = s[0]
b = s[1]
a,b,c,d,e=s
只打印出 对应的 a 和 e的值,使用'_'来填充中间的变量, '_'约定俗称代表丢弃的变量
a,_,_,_,e = s
a,*_,e #使用*_ 代表中间全部