数据类型分类
一：可变不可变
可变：列表，字典
不可变：数字，字符串，元组
二：存放值的个数
一个值：数字，字符串
多个值(容器类型)：列表，元组，字典
三：取值方式
直接取值：数字
序列类型：字符串，元组，列表
映射类型：字典
可变或者不可变的定义:在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 #使用*_ 代表中间全部
一：可变不可变
可变：列表，字典
不可变：数字，字符串，元组
二：存放值的个数
一个值：数字，字符串
多个值(容器类型)：列表，元组，字典
三：取值方式
直接取值：数字
序列类型：字符串，元组，列表
映射类型：字典
可变或者不可变的定义:在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 #使用*_ 代表中间全部