介绍：
1.什么是数据？
例：x=10,10是我们要存储的数据
2.为何数据要分不同的类型？
数据是用来表示状态的，不同的状态用不同的类型的数据去表示
1.数据类型
1.数字（整形，长整形，浮点型，复数）
整形int
#一：基本使用
1 用途
用途：年龄，等级，qq号等
2 定义方式
age=18 #age=int（18）
3 常用操作+内置的方法
+ - * / 等
#二：该类型总结
存一个值or存多个值
只能存一个值
没有顺序（只能存一个值）
可变or不可变（值改变id不变叫可变类型）
！！！不可变：值变，id就变。不可变==可hash
例：x=
print(id(x))
x=
print(id(x))
不可变==可hash
print（hash11）可以正常hash
补充：列表(值改了但是id不变为可变类型)为可变类型==不可hash
例l=[,,]
print(id(l))
[]=
print(id(l))
浮点型float
1 用途
身高，体重，工资，*参数等
2 定义方式
salary=3.1 #salary=float（3.1）
3 常用操作+内置的方法
#二：该类型总结
1 存一个值or存多个值
只能存一个值
2 没有顺序，只能存一个值
3 可变or不可变
！！！不可变：值变，id就变。不可变==可hash
了解：
长整型long
在python2中有，python3中没有
long（表示数字的长度过长）
例：
x=3L print(type（x）)
y=123123123123123 print(type(y))
复数complex
x=1+2j（j这个地方为什么定义其他的字符报错）
1代表实数
2代表虚数
print（x.real）查看实数
print（x.imag）查看虚数
print（type（x））
字符串floor
字符串
#一：基本使用
用途
姓名，性别，住址等描述性数据
定义方式
在单引号\双引号\三引号内，由一串字符组成
例：
msg='hello world'
这个字符串中的单个字符可以取出来，单个取出来的也叫字符串
#优先掌握的操作：
#、按索引取值(正向取+反向取) ：只能取,不能修改
print（msg[]，type(msg[])）取出hello world的第一个值
print(msg[-])取出最后一个值
不可以改字符串中的值
#、切片(顾头不顾尾，步长)
print（msg[:]）#>=<
print（msg[:]）#>=<
print（msg[::]）#>=<
print（msg[::]）#>=< #隔一个取一个（顾头不顾尾）
print（msg[:]）从开头到结尾
print（msg[:]）指的是从6开头到1，这没有可以取的东西了
print（msg[::-]）这个首先是倒序取值，这样的就是指的倒着从6到1，就可以取出来了
print（msg[-::-]）倒着取，这个0可以不加
#、长度len
按着字符串中的一个个字符算的
print（msg.__len__()）python内部调用的功能
print(len(msg))#就是msg.__len__()
#、成员运算in和not in
msg='hello world'
print(’llo’ in msg)#判断这个llo子字符串在不在这个msg字符串中
print(llo not in msg)#这里的not in是取反的意思
#、移除空白strip
password=' alex3714 '#如果多输入几个空格
print（password.strip()）#取出多余的空格
password=input('>>>:').strip#可以这样写，input接收用户输入的内容都存为字符串
password='alex 3714 '
print(password.strip())
#、切分split
user_info='root:x:0:0:/root:/bin/bash'
user_info.split(self,sep（sep指的是分隔符）,maxsplit这里面有三个参数，现在可以忽略掉self这个参数，只有两个)
res=user_info.split(':')
print(res[])#这样可以取出root这个值 file_path='c:\\a\\b\\c\\d.txt'#双\\指的是windows中的目录
print(file_path.split('\\',))这个取出的是以第一个\\为分隔符
print(file_path.rsplit('\\',))这个是从右边以第一个\\为分隔符
#7、循环
#把每个字符都打印出来
msg='hello world'
n=#来个索引等于0，根据索引取值
size=len(msg)
while n<size:
print(msg[n])
n+=
第二种方式：
不依赖索引
for i in msg:
print(i)
第三种方式：用for的索引方式取值
msg='hello world'
n=
for i in range(,):#range范围，顾头不顾尾，这个地方还可以指定步长
while n<i:
print(msg[n])
n+=
第四种方式：
msg='hello world'
n=
for i in range(,len(msg)):#len取出长度，如果range（这里面只写一个3，指的就是从0到3）
print(msg[i])
#二：该类型总结
1 存一个值or存多个值
只能存一个值
2 有序（能按照索引取值）
3 可变or不可变
！！！不可变：值变，id就变。不可变==可hash
需要掌握的
#、strip,lstrip,rstrip
print('***alex***'.strip('*'))
print('***alex***'.ltrip('*'))
print('***alex***'.rtrip('*'))
#、lower,upper
print('ALEX'.lower())#都改成小写
print('aaa'.upper())#都改成大写
#、startswith,endswith
msg='alex is SB'
print(msg.startswith('alex'))#以alex开头
print(msg.startswith('a'))#a开头
print(msg.endswith('SB'))#以SB结尾
#、format的三种玩法(格式赋值)
print('my name is %s my age is %s' $('alex',))
'my name is {} my age is {}'.format('alex',)按照顺序传值
print（'my name is {name} my age is {age}'.format(age=,name='alex')#不依赖于位置（常用）
print（'{0} {1} {0}'.format('alex',)）
#、split,rsplit(把一个字符串切成一个列表)
info='root:x:0:0'
l=info.split(':')
print(l)
#、join（把一个列表按照分隔符变成一个字符串）
':'.join(l)
print(':'.join(l))
反例：
l=[,,]
print(':'.join(l))#只有在列表中的元素全是字符串类型，才能用join拼接
#、replace(取代)（有三个参数old老的值，new要改成什么值，count改几次）
msg='alex say my name is alex,alex have on tesla'
msg=msg.replace('alex','SB'，)#字符串是不可变类型，压根不能改，要改的话只能存成一个新的值，加上1就代表只改第一个
print(msg) #、isdigit（判断字符串内是不是纯数字）
age=input('>>>:').strip()
print（age.isdigit()）#用户如果输入的是123或其他的数字返回值为True，否则False
age=int(age)有一个猜年龄的程序，age用int只能把字符串中的数字转成整形才能做if判断和数字的比较
age=input('>>>:').strip()
if age.isdigit()：
age=int（age）
else：
print（'必须输入数字'） age=int(age)
了解
#、find,rfind,index,rindex,count
msg='hello world'
print(msg.find('wo'))#返回值为6，就是说能找到第一个字符串的索引（默认从左边开始找，rfind就是从右边找）
print(msg.find('SB'))#没有SB，所以返回-
print(msg.index('SB'))#这个的返回值就会报错
print(msg.count('l'))#统计l这个字符串就是3个
print（msg.count('SB')）#返回值为0 #、center,ljust,rjust,zfill（跟打印效果有关）
print('egon'.center(,*))#30为指定宽度，*为填充的字符串，egon集中显示
print('egon'.ljust(,*))#左对齐
print('egon'.rjust(,*))#右对齐
print('egon'.zfill())#以0为填充符，默认往右对其
#、expandtabs跟tab有关
print('hello\tworld'.expandtabs())
#、captalize,swapcase,title
print('i am egon'.capitalize())#首字母大写
print('i am egon'.title())#每一个单词首字母大写
print('i am egon'.swapcase())#大小写反转 #、is数字系列
#在python3中
#isdigit能判断bytes，unicode
print(num1.isdigit())#
num1=b'' #bytes
num2=u'' #unicode,python3中无需加u就是unicode#返回值True
num3='四' #中文数字#返回值False
num4='Ⅳ' #罗马数字#返回值False #isnumeric能判断unicode
print（num2.isdecimal()）True
print（num3.isdecimal()）False
print（num4.isdecimal()）False #isnumeric来判断unicode,中文，罗马
print（num2.isnumeric()）True
print（num3.isnumeric()）True
print（num4.isnumeric()）True
#、is其他
print('===>')
name='egon123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成 print(name.isidentifier())#字符串包含关键字
print(name.islower())#全都是小写字母用
print(name.isupper())#判断大写
print(name.isspace())#判断是不是空格
print(name.istitle())#判断是不是标题（首字母大写是标题）
列表list
#作用：多个装备，多个爱好，多门课程，多个女朋友等 #定义：[]内可以有多个任意类型的值，逗号分隔
# my_girl_friends=['alex','wupeiqi','yuanhao',,] #本质my_girl_friends=list([...])
# print(list('hello'))#list会产生一个列表
# print(int(''))
# print(str())#优先掌握的操作：
#、按索引存取值(正向存取+反向存取)：即可存也可以取
#、切片(顾头不顾尾，步长)
#、长度
my_girl_friends=['alex','wupeiqi','yuanhao',,]
print(len(my_girl_friends))
#、成员运算in和not in
print('wupeiqi' in my_girl_friends)
#、追加
my_girl_friends[]=#IndexError: list assignment index out of range
对用的索引只能取出值或者修改值，不能追加
my_girl_friends.append()
print(my_girl_friends)
#、删除
del my_girl_friends[]
pirnt(my_girl_friends)
#单纯的删除
my_girl_friends.remove('yuanhao')
#列表中删除并想拿到结果：取走
res=my_girl_friends.pop()#pop()括号中如果没有值就从末尾去删
print(res) my_girl_friends=['alex','wupeiqi','yuanhao',,]
print(my_girl_friends.pop())#拿走alex
print(my_girl_friends.pop())#拿走wupeiqi
print(my_girl_friends.pop())#拿走yuanhao
#、循环
my_girl_friends=['alex','wupeiqi','yuanhao',,]
i=
while i<len(my_girl_friends):
print(my_girl_friends)
i+=
第二种方法：
for item in my_girl_friends：
print（item） 例子：1到10，不打印出7，用for
for item in range（）：
if item==：
pass
continue
print(item)
else:(上面只要不被break打断就执行else)
print('>>>:')
掌握的方法：
my_girl_friends=['alex','wupeiqi','yuanhao',,]
my_girl_friends.insert(，'egon')#指定索引
print(my_girl_friends) my_girl_friends.clear()#清空掉
print(my_girl_friends) l=my_girl_friends.copy()#拷贝一个列表
print（l） my_girl_friends.count('yuanhao')#统计个数 my_girl_friends.extend()#往列表中加值
# l=['egon1','egon2']
# my_girl_friends.extend(l)
# my_girl_friends.extend('hello')
# print(my_girl_friends) print（my_girl_friends.index('wupeiqi')）#取出索引值 print(my_girl_friend.reverse())#把值翻转输出 #排序sort
l=[,,,,]
l.sort()
print(l) 倒着排序
l.sort(reverse=True)
print(l) l=[,,,,，'a']#不行，因为数字和字符串不能比较大小 x='helloworld'
y='z'
print(y>x)#这个是根据abcd来比较的，因为z在h的后面
#二：该类型总结
1 存一个值or存多个值
可以存多个值，值都可以是任意类型
2 有序
3 可变or不可变
！！！可变：值变，id不变。可变==不可hash
元组tuple
#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读 #定义：与列表类型比，只不过[]换成()
age=(,,,,)本质age=tuple((,,,,))
print(type(age))
验证元组不可变：#元组没有变取决于id
age=(,,,,)
age[]=#报错，提示不支持修改
t=(,,['a','b'])
t[]=='xxx'#代表把元组中的元素改掉了，但是元组是不能改的，但是可以改元素内部的值
t[][]='A'
print(t)
这个地方只是把表中的a改成了A但是id没有变 #优先掌握的操作：
#、按索引取值(正向取+反向取)：只能取
#、切片(顾头不顾尾，步长)
age=(,,,,)
print(age[:])
print(age) #、长度
print(len(age))
#、成员运算in和not in
print( in age)
#、循环
for item in age:
print(item) 掌握
age=(,,,,)
print(age.index())#找索引
print(age.count())#找个数
#二：该类型总结
1 存一个值or存多个值
可以存多个值，值都可以是什么类型
2 有序
3 可变or不可变
！！！不可变：值变，id就变。不可变==可hash
字典dict
#作用：存多个值,key-value存取，取值速度快 #定义：key必须是不可变类型（int,float,str,tuple），value可以是任意类型
定义字典方式info={'name':'egon','age':,'sex':'male'} #本质info=dict({....})
或
了解
info=dict(name='egon',age=,sex='male')
或
info=dict([['name','egon'],('age',)，（'sex','male'）])
或
info={}.fromkeys(('name','age','sex'),None)#快速产生空字典
info={}.fromkeys('hello',None)
print(info)
#优先掌握的操作：
#、按key存取值：可存可取
d={'name':'egon'}
print(d['name']) d=['age']=#存数据
print(d)
#、长度len
info={'name':'egon','age':,'sex':'male'}
print(len(info)) #、成员运算in和not in
info={'name':'egon','age':,'sex':'male'}
print('name' in info) #、删除
info={'name':'egon','age':,'sex':'male'}
print(info.pop('name'))#对于列表如果不加索引默认是从右边删除，但是字典是无序的，pop必须要传key
print(info) print(info.popitem())#item就是一个元素，在字典key:value算是一个元素，所以出来的即有key也有value
print（info）#最右边的那个值就拿出来了
#、键keys()，值values()，键值对items()了解
print(info.keys())#输出的值像是以列表的形式取出
但是print(info.keys()[])#没法取出值，所以不是列表
这个key的值可以用来做for循环,for循环不依赖索引
for key in info.keys():
print(key) print(list(info.keys()))#这个是真正的裂变加[],可以取值 print(list(info.keys())) print(info.items())#转成真正的列表print(list（info.items())) #、循环
info={'name':'egon','age':,'sex':'male'}
for k in info:
print(k,info[k]) 其他需要掌握的方法
info={'name':'egon','age':,'sex':'male'}
print(info['hobbies'])#不存在的key，就会报错
print(info.get('hobbies'))#不会报错，返回none
print(info.get('hobbies','没有'))#这个的返回值就是‘没有’ info.pop('name1','xxx')
print(info.pop('name1','xxx'))#这个的返回值就是‘xxx’，跟get差不对 info.update
info={'name':'egon','age':,'sex':'male'}
d={'x':,'y',,'name':'EGON'}
info.update(d)#原来的字典没有我给你加上，如果有就更新刚给赋的值
print(info) info.setdefault()
info={'name':'egon','sex':'male'}
value=info.setdefault('age',)#字典中新增一个key：value这个元素，增进去会有个返回值，返回值是曾进去的value
print(value) info={'name':'egon','age',,'sex':'male'}
value=info.setdefault('age',)#字典中如果不存在我就把这个key：value加进去，并且返回值是value，如果有这个就不覆盖，返回原来有的值
print(value)
print(info) info={'name':'egon'}
info['hobbies']=[]
info['hobbies'].append('music')
info['hobbies'].append('read')
print(info) info={'name':'egon'，'hobbies':['music']}
if 'hobbies' not in info:
info['hobbies']=[]
else:
info['hobbies'.append('read')]
用setdefault实现
info={'name':'egon'，'hobbies':['music']}
hobbies_list=info.setdefault('hobbies',[])
print(hobbis_list)
hobbies_list.append('read')
hobbies_list.append('play')
print(info)
#二：该类型总结
存一个值or存多个值
可以存多个值，值都可以是任意类型，key必须是不可变类型 无序 可变or不可变
！！！可变：值变，id不变。可变==不可hash
集合引入
# pythons=['egon','axx','ysb','wxx']
# linuxs=['egon','oldboy','oldgirl','smallboy','smallgirl']
#
# python_linux=[]
#
# for student in pythons:
# if student in linuxs:
# python_linux.append(student)
#
# print(python_linux)
集合set
#作用：关系运算，去重
#定义集合：{}内用逗号分割每个元素都必须是不可变类型,元素不能重复,无序
# s={,'a',[,]} #TypeError: unhashable type: 'list'，不可哈希就是可变类型，可变就不能当字典元素
# s={,,,} #s=set({,,,})
# print(s,type(s))
注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值 #优先掌握的操作：
#、长度len
# s={,,,} #s=set({,,,})
# print(len(s)) #、成员运算in和not in
# names={'egon','alex'}
# print('egon' in names) #、|合集
pythons={'egon','axx','ysb','wxx'}
linuxs={'egon','oldboy','oldgirl','smallboy','smallgirl'} #、&交集:同时报名两门课程的学生
# print(pythons & linuxs)
# print(pythons.intersection(linuxs)) #、|合集:老男孩所有的学生
# print(pythons | linuxs)
# print(pythons.union(linuxs)) #、^对称差集:没有同时报名两门课程
# print(pythons ^ linuxs)
# print(pythons.symmetric_difference(linuxs)) #7.1 -差集：只报名python课程的学生
# print(pythons - linuxs)
# print(pythons.difference(linuxs)) #7.2 -差集：只报名linux课程的学生
# print(linuxs-pythons) # 父集:>,>=,子集：<，<=
# s1={,,}
# s2={,,}
# print(s1 >= s2)
# print(s1.issuperset(s2))#s1是s2它爹
# print(s2.issubset(s1))#判断S2是S1它儿子 # linuxs={'egon','oldboy','oldgirl','smallboy','smallgirl'}
# for student in linuxs:
# print(student) #了解的知识点
# s1={,,}
# s2={,,}
# print(s1-s2)
# print(s1.difference(s2))
# s1.difference_update(s2) #s1=s1.difference(s2)
# print(s1) # s2={,,,,,'a'}
# print(s2.pop()) # s2.add('b')
# print(s2) # s2.discard('b')
# s2.remove('b') #删除的元素不存在则报错
# print(s2) # s1={,,,,,'a'}
# s2={'b','c',}
# print(s1.isdisjoint(s2)) #两个集合没有共同部分时，返回值为True # s2={,,,,,'a'}
# s2.update({,,})
# print(s2) 去重：
# l=['a','b',,'a','a']#s=set()print(s)set指的是去掉重复的
# print(list(set(l)))# # print(set('hello'))#一个个输出，没有顺序
# print(set({'a':,'b':,'c':}))##for循环字典得到的就是Key s1={,,}
s2={,,}
print(s1-s2)#s1并不变
print(s1.difference(s2))
print(s1.defference_update(s2))#减完了以后并更新相当于赋值操作s1=s1.difference(s2)
print(s1)
了解的知识点：
s1={,,,,,'a'}
print(s1.pop())#删的意思,随机删
s1.add('b')#只能添加不可变类型进去
print（s1.add('b')）
s1.discard(s1)#明确指出删除的值#
s1.remove('b')#如果用这个删除集合中没有的字符串会报错，discard就不会报错 s1={,,,,,'a'}
s2={'b','c'}
print(s1.isdisjoint(s2))#两个集合没有共同部分时，返回值为True s1={,,,,,'a'}
s2.update({,,})#add只能加一个值，update可以加多个值
print(s2)
数据类型总结：
按存储空间的占用分（从低到高）
数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改
按存值个数区分
| 标量／原子类型 | 数字，字符串 |
| 容器类型 | 列表，元组，字典 |
按可变不可变区分
| 可变 | 列表，字典，集合 |
| 不可变 | 数字，字符串，元组 |
按访问顺序区分
| 直接访问 | 数字 |
| 顺序访问（序列类型） | 字符串，列表，元组 |
| key值访问（映射类型） | 字典 |
字符编码：
字符编码总结：
1.存取文件不乱码的法则：用什么编码存的，用什么编码读
2.unicode----------encode-------->转成其他编码gbk,叫做encode
gbk-------->decode----------->unicode
3. python3解释器默认使用的字符编码是utf-8
python2解释器默认使用的字符编码 ascii
4.python2的str就是python3的bytes
python2的unicode就是python3的str
文件处理：
f=open( 'a.txt','rt'，encoding='utf-8')#r默认就是rt文本模式#是操作系统打开这个文件，windows默认编码是gbk，而我存的是utf-8存的,所以我们要加上encoding='utf-8'，告诉操作系统用utf-8打开，就不会报错了
data=f.read()#对出文件内容
print（data）
f.close()#关闭文件，回收的是操作系统的资源
如果这个时候在f.read(),就看不到了，因为文件关闭，操作系统已经回收了资源，所以看不到
with open( 'a.txt','rt'，encoding='utf-8') as f：#文件打开的值给f
pass#执行完这个子代码后with会自动执行f.close()操作，避免忘记close()操作
f=open( 'a.txt','rt'，encoding='utf-8')
data=f.read()
print('==1=>',data1)
data2=f.read()#这个意思是光标从文件的开始已经到了结尾，如果在print下面的2就为空了
print(==2=>,data2)
print(f.readline())#代表的是每次读一行
print(f.readline())#这个跟上面的输出结果会有空格（换行），想取消print换行就 print(f.readline()，end='')
print(f.readlines())#这个也是吧文件中的内容都读出来，但是会把文件内容放到列表中去
只限文件小的时候，因为如果文件过大，一下就会读到内存中去
写操作
f=open( 'a.txt','w'，encoding='utf-8')#如果用r并且没有a.txt这个文件，那么就会报错，用w的话不会报错，没有这个文件就会造出这个文件出来，如果文件存在，还用w，就是相当于有创建了个文件，并把文件原来的文件覆盖掉了
f=open( 'a.txt','w'，encoding='utf-8')
f.write('1111\n')
f.write('2222\n')#还可以f.write('111\n222\n')
f.close()
f.writelines(['哈哈哈\n','你好'，'alex'])#可以通过列表或元组形式写到里面去