python数据类型、字符编码、文件处理

介绍：

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'])#可以通过列表或元组形式写到里面去