1 、数据类型
数字（整形，长整形，浮点型，复数）
字符串
字节串：在介绍字符编码时介绍字节bytes类型
列表
元组
字典
集合
2、数字
整型与浮点型
#整型int
作用：年纪，等级，身份证号，qq号等整型数字相关
定义：
age=10 #本质age=int(10)
#浮点型float
作用：薪资，身高，体重，体质参数等浮点数相关
salary=3000.3 #本质salary=float(3000.3)
#二进制，十进制，八进制，十六进制
3、
字符串
#作用：名字，性别，国籍，地址等描述信息
#定义：在单引号\\双引号\\三引号内，由一串字符组成
name=‘egon‘
#优先掌握的操作：
#1、按索引取值(正向取+反向取) ：只能取
#2、切片(顾头不顾尾，步长)
#3、长度len
#4、成员运算in和not in
#5、移除空白strip
#6、切分split
#7、循环
需要掌握的操作
#1、strip,lstrip,rstrip
#2、lower,upper
#3、startswith,endswith
#4、format的三种玩法
#5、split,rsplit
#6、join
#7、replace
#8、isdigit
#strip
name=‘*egon**‘
print(name.strip(‘*‘))去*
print(name.lstrip(‘*‘))去左边*
print(name.rstrip(‘*‘))去右边*
#lower,upper
name=‘egon‘
print(name.lower())把字符串变成全小写
print(name.upper())把字符串变成全大写
#startswith,endswith
name=‘alex_SB‘
print(name.endswith(‘SB‘))#判断是不是以SB结尾的print一个返回值True或False
print(name.startswith(‘alex‘))#判断是不是以alex开始的print一个返回值True或False
#format的三种玩法
res=‘{} {} {}‘.format(‘egon‘,18,‘male‘) #按照位置一个对一个
print(res)
egon 18 male
res=‘{1} {0} {1}‘.format(‘egon‘,18,‘male‘) #根据元素的下标对应
print(res)
18 egon 18
res=‘{name} {age} {sex}‘.format(sex=‘male‘,name=‘egon‘,age=18)#根据key值对应
print(res)
egon 18 male
#split name=‘root:x:0:0::/root:/bin/bash‘ print(name.split(‘:‘)) #默认分隔符为空格 name=‘C:/a/b/c/d.txt‘ #只想拿到顶级目录 print(name.split(‘/‘,1)) name=‘a|b|c‘ print(name.rsplit(‘|‘,1)) #从右开始切分 #join tag=‘ ‘ print(tag.join([‘egon‘,‘say‘,‘hello‘,‘world‘])) #可迭代对象必须都是字符串 #replace name=‘alex say :i have one tesla,my name is alex‘ print(name.replace(‘alex‘,‘SB‘,1)) #isdigit：可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法 age=input(‘>>: ‘) print(age.isdigit())
其他操作（了解即可）
#1、find,rfind,index,rindex,count
#2、center,ljust,rjust,zfill
#3、expandtabs
#4、captalize,swapcase,title
#5、is数字系列
#6、is其他
#find,rfind,index,rindex,count
name=‘egon say hello‘
print(name.find(‘o‘,1,3)) #顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引
# print(name.index(‘e‘,2,4)) #同上,但是找不到会报错
print(name.count(‘e‘,1,3)) #顾头不顾尾,如果不指定范围则查找所有
#center,ljust,rjust,zfill
name=‘egon‘
print(name.center(30,‘-‘))
print(name.ljust(30,‘*‘))
print(name.rjust(30,‘*‘))
print(name.zfill(50)) #用0填充
#expandtabs
name=‘egon\\thello‘
print(name)
print(name.expandtabs(1))
#captalize,swapcase,title
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg=‘egon say hi‘
print(msg.title()) #每个单词的首字母大写
#is数字系列
#在python3中
num1=b‘4‘ #bytes
num2=u‘4‘ #unicode,python3中无需加u就是unicode
num3=‘四‘ #中文数字
num4=‘Ⅳ‘ #罗马数字
#isdigt:bytes,unicode
print(num1.isdigit()) #True
print(num2.isdigit()) #True
print(num3.isdigit()) #False
print(num4.isdigit()) #False
#isdecimal:uncicode
#bytes类型无isdecimal方法
print(num2.isdecimal()) #True
print(num3.isdecimal()) #False
print(num4.isdecimal()) #False
#isnumberic:unicode,中文数字,罗马数字
#bytes类型无isnumberic方法
print(num2.isnumeric()) #True
print(num3.isnumeric()) #True
print(num4.isnumeric()) #True
#三者不能判断浮点数
num5=‘4.3‘
print(num5.isdigit())
print(num5.isdecimal())
print(num5.isnumeric())
‘‘‘
总结:
最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
如果要判断中文数字或罗马数字,则需要用到isnumeric
‘‘‘
#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())
列表
#作用：多个装备，多个爱好，多门课程，多个女朋友等
#定义：[]内可以有多个任意类型的值，逗号分隔
my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,4,5] #本质my_girl_friends=list([...])
或
l=list(‘abc‘)
#优先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可存也可以取
#2、切片(顾头不顾尾，步长)
#3、长度
#4、成员运算in和not in
#5、追加
#6、删除
#7、循环
#ps:反向步长
l=[1,2,3,4,5,6]
#正向步长
l[0:3:1] #[1, 2, 3]
#反向步长
l[2::-1] #[3, 2, 1]
#列表翻转
l[::-1] #[6, 5, 4, 3, 2, 1]
列表
#作用：多个装备，多个爱好，多门课程，多个女朋友等
#定义：[]内可以有多个任意类型的值，逗号分隔
my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,4,5] #本质my_girl_friends=list([...])
或
l=list(‘abc‘)
#优先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可存也可以取
#2、切片(顾头不顾尾，步长)
#3、长度
#4、成员运算in和not in
#5、追加
#6、删除
#7、循环
#ps:反向步长
l=[1,2,3,4,5,6]
#正向步长
l[0:3:1] #[1, 2, 3]
#反向步长
l[2::-1] #[3, 2, 1]
#列表翻转
l[::-1] #[6, 5, 4, 3, 2, 1]
字典
#作用：存多个值,key-value存取，取值速度快
#定义：key必须是不可变类型，value可以是任意类型
info={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘} #本质info=dict({....})
或
info=dict(name=‘egon‘,age=18,sex=‘male‘)
或
info=dict([[‘name‘,‘egon‘],(‘age‘,18)])
或
{}.fromkeys((‘name‘,‘age‘,‘sex‘),None)
#优先掌握的操作：
#1、按key存取值：可存可取
#2、长度len
#3、成员运算in和not in
#4、删除
#5、键keys()，值values()，键值对items()
#6、循环
集合
#作用：去重，关系运算，
#定义：
知识点回顾
可变类型是不可hash类型
不可变类型是可hash类型
#定义集合:
集合：可以包含多个元素，用逗号分割，
集合的元素遵循三个原则：
1：每个元素必须是不可变类型(可hash，可作为字典的key)
2:没有重复的元素
3：无序
注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
#优先掌握的操作：
#1、长度len
#2、成员运算in和not in
#3、|合集
#4、&交集
#5、-差集
#6、^对称差集
#7、==
#8、父集：>,>=
#9、子集：<,<=
运算符
#身份运算（is ，is not）
is比较的是id，而双等号比较的是值
毫无疑问，id若相同则值肯定相同，而值相同id则不一定相同
>>> x=1234567890
>>> y=1234567890
>>> x == y
True
>>> id(x),id(y)
(3581040, 31550448)
>>> x is y
False
！！！总结非常重要的两点！！！
#1、保证不乱吗的核心法则就是，字符按照什么标准而编码的，就要按照什么标准解码，此处的标准指的就是字符编码
#2、在内存中写的所有字符，一视同仁，都是unicode编码，比如我们打开编辑器，输入一个“你”，我们并不能说“你”就是一个汉字，此时它仅仅只是一个符号，该符号可能很多国家都在使用，根据我们使用的输入法不同这个字的样式可能也不太一样。只有在我们往硬盘保存或者基于网络传输时，才能确定”你“到底是一个汉字，还是一个日本字，这就是unicode转换成其他编码格式的过程了
unicode----->encode-------->utf-8
utf-8-------->decode---------->unicode
#补充：
浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器
如果服务端encode的编码格式是utf-8， 客户端内存中收到的也是utf-8编码的结果。
字符编码应用之python
执行python程序的三个阶段
阶段一：启动python解释器
阶段二：python解释器此时就是一个文本编辑器，负责打开文件test.py,即从硬盘中读取test.py的内容到内存中
阶段三：读取已经加载到内存的代码（unicode编码格式），然后执行，执行过程中可能会开辟新的内存空间，比如x="egon"
在python3 中有两种字符串类型str和bytes
str是unicode
#coding:gbk
x=‘上‘ #当程序执行时，无需加u，‘上‘也会被以unicode形式保存新的内存空间中,
print(type(x)) #<class ‘str‘>
#x可以直接encode成任意编码格式
print(x.encode(‘gbk‘)) #b‘\\xc9\\xcf‘
print(type(x.encode(‘gbk‘))) #<class ‘bytes‘>
很重要的一点是：看到python3中x.encode(‘gbk‘) 的结果\\xc9\\xcf正是python2中的str类型的值,而在python3是bytes类型，在python2中则是str类型
于是我有一个大胆的推测：python2中的str类型就是python3的bytes类型，于是我查看python2的str()源码，发现
在python中
#1. 打开文件，得到文件句柄并赋值给一个变量
f=open(‘a.txt‘,‘r‘,encoding=‘utf-8‘) #默认打开模式就为r
#2. 通过句柄对文件进行操作
data=f.read()
#3. 关闭文件
f.close()
三 f=open(‘a.txt‘,‘r‘)的过程分析
#1、由应用程序向操作系统发起系统调用open(...)
#2、操作系统打开该文件，并返回一个文件句柄给应用程序
#3、应用程序将文件句柄赋值给变量f
四 强调！！！
#强调第一点：
打开一个文件包含两部分资源：操作系统级打开的文件+应用程序的变量。在操作完毕一个文件时，必须把与该文件的这两部分资源一个不落地回收，回收方法为：
1、f.close() #回收操作系统级打开的文件
2、del f #回收应用程序级的变量
其中del f一定要发生在f.close()之后，否则就会导致操作系统打开的文件还没有关闭，白白占用资源，
而python自动的垃圾回收机制决定了我们无需考虑del f，这就要求我们，在操作完毕文件后，一定要记住f.close()
虽然我这么说，但是很多同学还是会很不要脸地忘记f.close(),对于这些不长脑子的同学，我们推荐傻瓜式操作方式：使用with关键字来帮我们管理上下文
with open(‘a.txt‘,‘w‘) as f:
pass
with open(‘a.txt‘,‘r‘) as read_f,open(‘b.txt‘,‘w‘) as write_f:
data=read_f.read()
write_f.write(data)
#强调第二点：
f=open(...)是由操作系统打开文件，那么如果我们没有为open指定编码，那么打开文件的默认编码很明显是操作系统说了算了，操作系统会用自己的默认编码去打开文件，在windows下是gbk，在linux下是utf-8。
这就用到了上节课讲的字符编码的知识：若要保证不乱码，文件以什么方式存的，就要以什么方式打开。
f=open(‘a.txt‘,‘r‘,encoding=‘utf-8‘)
五、打开文件的模式
文件句柄 = open(‘文件路径‘, ‘模式‘)
模式可以是以下方式以及他们之间的组合：
| Character | Meaning |
| ‘r‘ | open for reading (default) |
| ‘w‘ | open for writing, truncating the file first |
| ‘a‘ | open for writing, appending to the end of the file if it exists |
| ‘b‘ | binary mode |
| ‘t‘ | text mode (default) |
| ‘+‘ | open a disk file for updating (reading and writing) |
| ‘U‘ | universal newline mode (for backwards compatibility; should not be used in new code) |
#1. 打开文件的模式有(默认为文本模式)：
r ，只读模式【默认模式，文件必须存在，不存在则抛出异常】
w，只写模式【不可读；不存在则创建；存在则清空内容】
a， 之追加写模式【不可读；不存在则创建；存在则只追加内容】
#2. 对于非文本文件，我们只能使用b模式，"b"表示以字节的方式操作（而所有文件也都是以字节的形式存储的，使用这种模式无需考虑文本文件的字符编码、图片文件的jgp格式、视频文件的avi格式）
rb
wb
ab
注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码
#3. 了解部分
"+" 表示可以同时读写某个文件
r+， 读写【可读，可写】
w+，写读【可读，可写】
a+， 写读【可读，可写】
x， 只写模式【不可读；不存在则创建，存在则报错】
x+ ，写读【可读，可写】
xb
六、 操作文件的方法
#掌握
f.read() #读取所有内容,光标移动到文件末尾
f.readline() #读取一行内容,光标移动到第二行首部
f.readlines() #读取每一行内容,存放于列表中
f.write(‘1111\\n222\\n‘) #针对文本模式的写,需要自己写换行符
f.write(‘1111\\n222\\n‘.encode(‘utf-8‘)) #针对b模式的写,需要自己写换行符
f.writelines([‘333\\n‘,‘444\\n‘]) #文件模式
f.writelines([bytes(‘333\\n‘,encoding=‘utf-8‘),‘444\\n‘.encode(‘utf-8‘)]) #b模式
#了解
f.readable() #文件是否可读
f.writable() #文件是否可读
f.closed #文件是否关闭
f.encoding #如果文件打开模式为b,则没有该属性
f.flush() #立刻将文件内容从内存刷到硬盘
f.name
七：文件内光标移动
一: read(3)：
1. 文件打开方式为文本模式时，代表读取3个字符
2. 文件打开方式为b模式时，代表读取3个字节
二: 其余的文件内光标移动都是以字节为单位如seek，tell，truncate
注意：
1. seek有三种移动方式0，1，2，其中1和2必须在b模式下进行，但无论哪种模式，都是以bytes为单位移动的
2. truncate是截断文件，所以文件的打开方式必须可写，但是不能用w或w+等方式打开，因为那样直接清空文件了，所以truncate要在r+或a或a+等模式下测试效果
练习：基于seek实现tail -f功能五 文件的修改
文件的数据是存放于硬盘上的，因而只存在覆盖、不存在修改这么一说，我们平时看到的修改文件，都是模拟出来的效果，具体的说有两种实现方式：
方式一：将硬盘存放的该文件的内容全部加载到内存，在内存中是可以修改的，修改完毕后，再由内存覆盖到硬盘（word，vim，nodpad++等编辑器）
import os
with open(‘a.txt‘) as read_f,open(‘.a.txt.swap‘,‘w‘) as write_f:
data=read_f.read() #全部读入内存,如果文件很大,会很卡
data=data.replace(‘alex‘,‘SB‘) #在内存中完成修改
write_f.write(data) #一次性写入新文件
os.remove(‘a.txt‘)
os.rename(‘.a.txt.swap‘,‘a.txt‘)
方式二：将硬盘存放的该文件的内容一行一行地读入内存，修改完毕就写入新文件，最后用新文件覆盖源文件
import os
with open(‘a.txt‘) as read_f,open(‘.a.txt.swap‘,‘w‘) as write_f:
for line in read_f:
line=line.replace(‘alex‘,‘SB‘)
write_f.write(line)
os.remove(‘a.txt‘)
os.rename(‘.a.txt.swap‘,‘a.txt‘)