一、数字类型
1.int类型：
基本使用：
用途：用于年龄，手机号，身份证号；
定义：
age=18；
常用操作+内置方法：
正常的运算赋值；
进制转换：
print(bin(3)); 把十进制3转换成二进制并输出，结果为0b11
print(oct(8));把十进制8转换成八进制并输出，结果为0o10
print(hex(16));把十进制16转换成十六进制并输出，结果为0x10
2.float类型
基本使用：
用途：用于身高，体重，薪资；
定义：
heighe=1.81;
常用操作+内置方法：
正常的运算赋值；
3.int和float类型总结：
存一个值or多个值：
只能存一个值；
可变or不可变：
不可变； （值变id不变为可变，值变id跟着变为不可变）
二、字符串类型
1基本使用：
用途：描述性数据，用于名字，家庭住址，性别爱好；
定义方式：在单引号/双引号/三引号中的字符，注意：三引号用于多段字符，单引号内可用双引号，双引号套单引号，但不能，单引号内套单，双套双；
name='zhanglong'
掌握：str(10)，int('10')
str能将整型10转换为字符串’10‘ ，而int只能讲字符串’10‘转换为整型10，不能讲字符串’a‘转换为整型；
2.常用操作+内置方法：
优先掌握的操作：
1.安照索引取值：
name='zhanglong'
print(name[0]) #从前往后取,索引第一位对应的是0
结果为z；
print(name[-1]) #从后往前取，索引第一位对应的是-1
结果为g;
2.切片（顾头不顾尾，步长）
count='123456789'
print(count[0:6:1])
结果为：123456，0是开头，6是结尾，结尾不包括在内，也就是012345位，1是步长，走一步，0，再走1步，1；
count='123456789'
print(count[1:7:2])
结果为246，1是开头，对应的是2，走两步，23，输出4，走两步，45，输出6，7是结尾，不包括；
3.长度len
name='zhanglong'
print(len(name))
结果输出为9，也就是输出字符串的位数。
4.成员运算in和not in
in：在
not in：不在
name='zhanglong'
print('zhang' in name)
结果为True，也就是字符串’zhang‘在字符串name中，自然是正确的
name='zhanglong'
print('zhang' not in name)
结果为False，也就是字符串’zhang‘不在字符串name中，自然是错误的；
5.移除空白strip
test='*****练习*****'
print(test.strip('*'))
输出结果为：练习，两边的*被strip清除了，如何没加字符，会清除空格
6.切分split
name='zhanglong:zhoahu:wangerma'
print(name.split(':'))
结果为：['zhanglong', 'zhoahu', 'wangerma'] 字符串中统一的符号：被切除，并将其转换成列表模式输出，name并为被改边，只是结果改变，可以赋值个新的变量；
7.循环
name='zhanglong'
i=0
while i<len(name)
print(name[i])
i+=1;
用while循环 循环输出字符串中的字符；
name='zhaohu'
for ser in name:
print(ser)
用for循环，循环输出name的字符
3月20日补充
3.需要掌握的操作
1.strip.rstrip.lstrip
strip:去除字符两边的特殊符号；调用，字符串.strip()，（）可以输入其他字符，不输入则清除空白，输入则清除其他值；
rstrip：去除字符右边的特殊符号；调用，字符串.strip()，（）可以输入其他字符，不输入则清除空白，输入则清除其他值；
lstrip:去除字符左边的特殊符号；调用，字符串.strip()，（）可以输入其他字符，不输入则清除空白，输入则清除其他值；
2.lower.upper
lower:将字符串全部转换为小写；调用，字符串.lower();
upper:将字符串全部转换为大写；调用，字符串.upper();
3.startswith.endswith
startswith:判断字符串开头；调用，字符串.startswith()，（）内输入你要判断的字符，输出为真，则输入字符是次字符串的开头；
endswith：判断字符串结尾；调用，字符串endswith()，（）内输入你要判断的字符，输出为真，则输入字符是次字符串的结尾；
4.format的三种用法
format：字符串格式化；：第一种用法，字符串.format(),字符串中加入{}，（）内输入值，用逗号，隔开，按顺序替换{}；
format：字符串格式化；：第二种用法，字符串.format(),字符串中加入{}并且在{}中加入索引，（）内输入值，用逗号，隔开，按索引替换{}；
format：字符串格式化；：第一种用法，字符串.format(),字符串中加入{}并且在{}内输入值名，（）内输入值名值=值，用逗号，隔开，按你输入的值名替换{}；
5.split.rsplit
split:切分，把有规律的字符串中规律符号切分，得到列表；调用字符串.split()，（）括号内输入规律符号，或者你想分割的符号，符号后用逗号隔开输入你想切分次数，不输入则全部切分； rsplit：从右边切分，把有规律的字符串中规律符号切分，得到列表；调用字符串.split()，（）括号内输入规律符号，或者你想分割的符号，符号后用逗号隔开输入你想切分次数，不输入则全部切分；
6.join
join：以某字符为连接把列表合成字符串； 调用：''.join(列表)，join前输入你想要的连接符，不输入则空为连接符，（）内输入需要连接的列表；
注意：join方法传入的列表只能包含str类型的元素，也就是字符串类型的元素；
7.replace
replace：替换，把字符串中某些字符串替换成你想输入的字符串；调用：字符串.join(),（）内第一个输入被替换的，第二个输入你想替换的字符串，第三个你想替换的个数，空为全部替换，输入内容用逗号隔开；
8.isdigit
isdigit:判断字符串内是否都是数字（不能判断小数）；调用：字符串.isdigit.
2.字符串类总结
存一个值or存多个值
存一个值；
有序or无序
有序
可变or不可变
不可变
三、列表
作用：多个爱好， 多个课程，多个女朋友等；
定义：
cmd=['abc','aoe','iwy']
[]内用逗号分隔多个元素，列表内元素无类型限制；
或 l=list('abc') 用list创建列表，（）内为列表的值
常用操作+内置方法：
优先掌握的操作：
1、按索引存取值(正向存取+反向存取)：即可改也可以取
x=['a','b','c'] print(x[0]) x[0]='A'调用：列表名[]，[]内放索引，则取出列表值，把新的列表值赋予列表名[索引]，则更改其值
2、切片(顾头不顾尾，步长)
stus=['alex','egon','wxx','yxx','lxx']print(stus[1:3])
调用：列表名[],[]放三个值，第一个为头，第二个为尾，第三个为步长
方式与字符串相同
3、长度
stus=['alex','egon','wxx','yxx','lxx'] print(len(stus))调用：len（），（）放列表名，输入的是列表的个数；
4、成员运算in和not in
stus=['alex','egon','wxx','yxx','lxx'] print('alex' in stus)in==在，not in==不在
5、追加
stus=['alex','egon','wxx','yxx','lxx'] stus.append('wupei') stus.append('peiqi') print(stus)调用：列表名.append（）；（）内放入需要添加的值，添加永远只从后面添加；
6、插入 stus=['alex','egon','wxx','yxx','lxx'] stus.insert(1,'艾利克斯') print(stus)调用：列表名.insert（）；（）中第一位为列表索引，第二位为要插入的元素，以逗号分隔；
7、删除
stus=['alex','egon','wxx','yxx','lxx'] del stus[1] print(stus) stus.remove('alex') print(stus)调用：列表名.remove(),（）内为你要删除的元素；
stus.pop(1)
stus.pop() # 默认删除末尾 print(stus)调用：列表名.pop(),（）中为你需要删除的索引，不输入则默认删除索引；pop删除的元素可以赋值给别的变量；
res1=stus.remove('alex') # 单纯的删除
print(res1) res2=stus.pop(0) # 取走一个值 print(res2)
8、循环
stus=['alex','egon','wxx','yxx','lxx'] 依赖索引 i=0 while i < len(stus): print(stus[i]) i+=1循环输出；while；
for i in range(len(stus)):
print(i,stus[i])不依赖索引
for item in stus: print(item)循环输出；for；
补充for循环依赖索引for循环
for i in range(0,5,2): #0 2 4 print(i) for i in range(10):#默认从零起始 print(i)for i in range(10,-2,-1):
print(i)需要掌握的操作
stus=['alex','egon','alex','wxx','yxx','lxx']print(stus.count('alex'))
count：统计元素个数；用法：列表名.count(),（）输入你想统计的元素
stus.extend(['a','b','c'])
print(stus)extend:增加多个元素； 调用：变量名.extend(),（）输入[]，再在内放入多个元素，也可以说直接增加一个列表的元素；
print(stus.index('alex',1,5))
index:查找元素索引；调用：变量名.index();()可输入3个值，第一个为你要查找的元素，第二个为范围开头，第三个为范围结尾，不输入范围，从头查找；
stus.reverse()
print(stus)reverse：把整个列表倒过来；调用：变量名.reverse（）；
l=[1,10,3,12]
l.sort(reverse=True) print(l)sort：排序； 调用列表名.sort(),从小到大排序，（）输入reverse=True，从大到小排序；（注意，只能排序数字字符）
大前提：只能同类型直接比较大小，对于有索引值直接的比较是按照位置一一对应进行比较的
s1='hello' s2='hf' print(s1 > s2)l1=[3,'a','b','c']
l2=['xxx','d'] print(l1 > l2)print('Z' > 'a')
A-Za-z print('a' > 'B')字符串比大小，从第一位开始比，不同直接决定大小，相同向后排；小写字母到大写字母比较，小z为最大，大A 为最小；
补充for循环
enumerate:输出索引与列表的值 ； 调用：enumerate（列表名）；
goods=['mac','apple','iphone','tesla'] for i in range(len(goods)): #根据列表长度，输入索引和列表值 print(i,goods[i])print(enumerate(goods))
for x,y in enumerate(goods): #x,y=[0, 'mac'] #用enumerate来输出索引和值
print(x,y)s='hello'
for x,y in enumerate(s): #0h 1e 2l 3l 4o #用enumerate来输出索引和值 print(x,y)s='hello'
l=list() for item in s: print(item) l.append(item) print(l) list('hello')enumerate('hello') #(0, 'h') (1, 'e') ...
for item in enumerate('hello'): print(item) res=list(enumerate('hello')) print(res)
总结列表类型
多值
有序
可变；
四、元组
什么是元组：“元组就是一个不可变的列表”
1.用途：存多个值，但是只有读的需求，没有改的需求
强调：在元素个数相同的情况下，使用元组更加节省空间2 定义方式
t=(1,2,3,4) #t=tuple((1,2,3,4))print(id(t),type(t),t)
3 常用操作+内置的方法
优先掌握的操作： 1、按索引取值(正向取+反向取)：只能取 2、切片(顾头不顾尾，步长) t=(1,2,3,4,5,6) print(t[1:4])print(tuple('hello')) #创建一个元组b并输出
for i in range(10000): # print(i)print(tuple(range(10000)))
3、长度
4、成员运算in和not in5、循环
t=('a','b','c','c')
print(t.index('a')) print(t.count('c')) 该类型总结 1 存多个值 2 有序 3 不可变五、字典
1 用途：以key：value的形式存多个值
优点：存取都快，每一个值都有对应的key
2 定义方式:{}内以逗号分隔多个元素，格式为key:value，
其中key必须为不可变类型，value可以是任意类型 dic={'x':1,'y':1,'x':1111} #dic=dict({'x':1,'y':1,'x':1111}) print(dic)dic=dict(x=1,y=2,z=3)
print(dic) 3 常用操作+内置的方法 优先掌握的操作： 1、按key存取值：可存可取 dic={'name':'egon'} dic['age']=10 #增加一个字典元素 print(dic) dic['name']='EGON' #更改name的值 print(dic)dic['name']=dic['name'].upper() #将name映射的值改为大写
print(dic)2、长度len
dic={'name':'egon','age':18} print(len(dic))3、成员运算in和not in:判断的字典的key
4、删除
dic={'name':'egon','age':18} del dic['name'] #删除一个值 print(dic) res=dic.pop('name') #pop 取走一个值 print(res) print(dic)res=dic.pop('sex',None) #取走一个没有的值 返回为空
print(res)
5、键keys()，值values()，键值对items()
dic={'name':'egon','age':18} print(dic.keys()) #得出所有的键值 print(dic.values()) #得出值print(dic.items()) #打印出所有的键值，小元组的方式，for循环可以打印出一个一个键值
4、掌握的操作
dic={'name':'egon','age':18}
print(dic.get('namexxxxxxxxxxx'))get：用get输出值，不在里面就返回空
print(dic.popitem())
popitem():随机弹出一个元组形式的键值对
dic.setdefault()
setdefaul的用处：
1、字典有中有key，则不修改，返回原key对应的原值 dic={'name':'egon','age':18} res=dic.setdefault('name','EGON') print('返回值',res) print(dic)2、没有对应的key，则添加，返回添加的key对应的value
dic={'age':18} res=dic.setdefault('name','EGON') print('返回值',res) print(dic) #{'age': 18, 'name': 'EGON'}dic.update({'x':1,'age':19})
update：更新，对与老字典来说，更新指的是，新字典中有而老字典中没有则添加，新有而老有，则覆盖print(dic)
dic.fromkeys()
fromkeys:快速创建一个字典；print({}.fromkeys(['name','age','sex'],None))
{'name':None,'age':None,'sex':None}循环字典：
msg_dic={ 'apple':10, 'tesla':100000, 'mac':3000, 'lenovo':30000, 'chicken':10, }for key in msg_dic:
print(key,msg_dic[key])总结
1、存多个值 2、无序 3、可变六、集合用途
1、 关系运算2、去重 s1=set('hello') print(s1) #l=['a','b',1,'a','a']
print(list(set(l)))想去重还想保证原来的顺序：了解
l = ['a', 'b', 1, 'a', 'a'] l_new=[] s=set()for item in l:
if item not in s: s.add(item) #s={'a','b',1} l_new.append(item) #l_new=['a','b',1]定义方式:在{}内用逗号分隔开一个个元素
注意的问题 1、集合内没有重复的元素 2、集合的元素必须是不可变类型s={1,2,3,4,4,4,4,4,4,4,'a'} #s=set({1,2,3,4,'a'})
print(id(s),type(s),s)s={[1,2,3],'aa'}
常用操作与内置方法
stus_linux={'alex','egon','张全蛋','李铁蛋','oldboy'} stus_python={'李二丫','wxx','liudehua','alex','egon'}既报名linux又报名python的学生：交集
print(stus_linux & stus_python) print(stus_linux.intersection(stus_python))所有的学生：并集
print(stus_linux | stus_python) print(stus_linux.union(stus_python)) 只报名linux，没有报名python的：差集 print(stus_linux - stus_python) print(stus_linux.difference(stus_python)) print(stus_python - stus_linux) print(stus_python.difference(stus_linux))没有同时报名两门课程的学生姓名：交叉补集
print(stus_linux ^ stus_python) print(stus_linux.symmetric_difference(stus_python))优先掌握，循环取值
长度len 成员运算in和not in 查看 s1={1,'a','b','c','d'} for item in s1: print(item)增加
s1={'a','b','c'} s1.add() # 一次添加一个值 s1.add(4) print(s1)s1.update({3,4,5}) #一次添加多个值
print(s1)删除
s1.discard() ## 当删除的元素不存在的时候，不会报错 s1.discard(4) print(s1)s1.remove() # 当删除的元素不存在的时候，报错
s1.remove(4)s1.pop() #随机取走一个元素
res=s1.pop() print(res)了解的方法
s1={1,2,3}
s2={1,2} s1=s1.difference(s2) print(s1) s1.difference_update(s2) print(s1)s1.isdisjoint() #如果两个集合没有交集则返回True
s1={1,2,3} s2={4,5,6} print(s1.isdisjoint(s2)) print(s2.isdisjoint(s1))了解的知识点
父集:爹包含儿子 s1={1,2,3} s2={1,2} print(s1.issubset(s2)) print(s2.issubset(s1)) print(s1.issuperset(s2))print(s1 > s2) # 代表s1包含s2，s1是s2父集
print(s2 < s1) # s2是s1子集s3={1,2,3}
s4={1,2,3} print(s3.issuperset(s4)) print(s4.issuperset(s3)) print(s3 == s4) print( s3 >= s4) print( s4 >= s3)
七、字符编码
1、知识储备
cpu 内存 硬盘 2 文本编辑器存原理 结论：在编写py的程序的时候，是没有语法的限制的，编辑的结果跟编写一个普通的文本文件是没有任何区别，只有把py程序交给python解释并且在运行的第三个阶段才有了 语言意义 3 python解释器执行python程序的原理 python3 test.py 第一阶段：先启动python解释器这个软件 第二阶段：把test.py文件的内容读入内存 第三阶段：解释执行，识别语法4 文本编辑器读原理
5：什么是字符编码
人类的字符----》翻译-------》数字 翻译的过程必须遵循一个标准:字符与数字一一对应的关系 这个标准称之为字符编码表ASCII
8bit=1bytes,一个英文字符占用1字节GBK
16bit=2bytes ，2个字节表示一个中文字符，1字节表示一个英文字符unicode(内存中固定的编码)：
16bit=2bytes,2个字节表示一个字符utf-8:Unicode Transformation Format
1字节表示一个英文字符,3bytes表示一个中文字符保证不乱吗的核心就是：
文件是以什么编码存的，就必须以该读取 强调：我们能控制的只是存到硬盘上的编码 python3解释器：默认utf-8编码 python2解释器：默认ascii编码文件头的作用：#coding:utf-8 是告诉python解释器，用我指定的字符编码
6：执行python程序第三个阶段发生的事
会识别python语法，定义的字符串类型又涉及到字符编码的概念 x='上' #x=str('上') python2: 字符串分为两种形式： x='上' #python2的str类型会按照文件头指定的编码来存‘上’python3：
str：被存成了unicode7：转换
unicode---编码encode--->gbk gbk------->解码decode---》unicodeprint(2**16-1)
整片字符编码一定要记住：文件是以什么编码存的，就用什么编码读取
八、文件处理
1、打开文件
f=open(r'文件的路径',mode='打开文件的模式',encoding='操作文件的字符编码') f=open(r'a.txt',mode='r') print(f) 2、读/写read():只读，输出文件里的全部内容
data=f.read() print(data) del f 3、关闭文件close() :关闭操作系统内的文件，回收操作系统的资源；
f.close() print(f) f.read()with:管理文件上下文操作，帮你打开文件，帮你关闭系统文件；还可连续管理多个文件定义过第一个文件后，用逗号定义第二个；
with open(r'a.txt',mode='r') as f: # 打开一个文件
print('===>') print(f.read()) #read 读取文件f1=open(r'a1.txt',mode='r')
f2=open(r'a2.txt',mode='r')with open(r'a1.txt',mode='r') as f1,open('a2.txt',mode='r') as f2: #管理2个文件，
print('===>') print(f1.read()) print(f2.read())4.默认的打开文件的编码是：当前操作系统默认的编码，win：gbk，linux：utf-8 mac：utf-8
encoding: 选择打开文件的编码；
f=open('a.txt',mode='r',encoding='utf-8')
print(f.read())
f.close()
5.文件默认的打开模式是t模式：文本模式
6.操作文件的模式有三种：r，w，a
r：默认的打开模式,只读模式
注意：当文件不存在时，报错f=open('a.txt',mode='r',encoding='utf-8') #mode='rt'
f.write('哈哈啊哈哈啊啊 啊啊123213213123\n') #抛出异常，不能写 print(f.readable()) #判断这个文件是不是可读的 print('=============>1') print(f.read()) #第一次打印 print('=============>2') print(f.read()) #第二次打印，read是全部打印，所以第二次打印无效 f.close()readline: 只读一行
f=open('a.txt',mode='r',encoding='utf-8') #mode='rt'
print(f.readline(),end='') # 读第一行print(f.readline(),end='') # 读第二行
print(f.readline(),end='') #读第三行 f.close()readlines: 以\n为分隔 把文件以列表的形式读出来
f=open('a.txt',mode='r',encoding='utf-8') #mode='rt' print(f.readlines()) f.close()for line in f.readlines(): #循环文件不要使用该方式，因为在文件过大的情况下有可能会撑爆内存
print(line,end='')with open('a.txt',encoding='utf-8') as f:
for line in f: #for循环输出f的值 print(line,end='') #去除换行w：只写模式
注意 1、当文件存在时，清空 2、当文件不存在时，创建空文档print(f.writable()) #判断是否是可写模式
write:写，用于往文件中写字符，注意不会自动换行，需要换行时请添加换行符
f=open(r'a1.txt',mode='w',encoding='utf-8') #默认是wt
f.write(‘第一行\n第二行') #写入第一行和第二行，用换行符隔开writelines:可以吧列表、元组写入文件
f.writelines(['111111\n','222222\n','333333\n']) #把列表写入，要写换行符
f.write('aaaa\nbbbb\ncccc\n') #把字符串写入，区别就是，一个写入列表类，一个写入字符串类 f.close()a：只追加写模式
注意： 在文件不存在时，创建空文件 在文件存在时，光标直接跑到文件末尾f=open('access.log',mode='a',encoding='utf-8') # 追加模式，操作与方法与写模式相同 ，并且不可读
f.readlines() #报错 证明不可读
f.write('5555555555555\n') #可写
f.close()
7.文件的打开模式b模式
强调： 1、与t模式类似不能单独使用，必须是rb，wb，ab 2、b模式下读写都是以bytes单位的 3、b模式下一定不能指定encoding参数 rb模式 with open('1.jpg',mode='rb',) as f: # 打开文件一1 data=f.read() #读文件，数据赋予data print(data,) #输出读的文件 print(type(data)) #输出data的格式with open('db.txt',mode='rb',) as f: #打开文件db
data=f.read() # 赋值 print(data.decode('utf-8')) #bytes-----unicode #字符编码转换 因为用的是rb模式，date的值为二进制，解码后才能输出人类字符； print(type(data)) #字符类型wb模式
with open('b.txt',mode='wb') as f: #用b模式只写打开b文件 msg='你好啊，吴三炮' f.write(msg.encode('gbk')) # 将msg编码成gbk模式写入 f with open('b.txt',mode='wb') as f: #用b模式只写打开b文件 msg='你好啊，吴三炮' f.write(msg.encode('utf-8')) #将msg的值编码为utf-8模式写入fwith open('b.txt',mode='rb') as f: #用b模式只读打开b文件
data=f.read() print(type(data)) #测试data的类型 print(data.decode('utf-8')) #用utf-8将data解码 with open('1.jpg',mode='rb') as f: #用b模式只读打开图片1data=f.read()
print(type(data)) #测试类型 print(data.decode('utf-8')) # 用utf-8解码dataab模式
用法与wb相同
with open('b.txt',mode='ab') as f: #用b模式追加打开文件b f.write('你好'.encode('utf-8')) #把'你好'用utf-8编码写入文件b8.可读可写模式（了解）
r+t ：读写模式，先读，然后可以写 with open('b.txt','r+t',encoding='utf-8') as f: #用读写模式打开b print(f.readable()) #判断是否可读 print(f.writable()) #判断是否可写 print(f.readline()) #读一行 f.write('\n吴大炮你也号\n') #写入 w+t 写读模式，先写入，然后可以读a+t 追读模式，一样先写入，后读
U ：通用换行符 （已经废弃）
9.修改文件方式一： 1、先把文件内容全部读入内存 2、然后在内存中完成修改 3、再把修改后的结果覆盖写入原文件 缺点：会在文件内容过大的情况下，占用过多的内存 with open('user.txt',mode='r',encoding='utf-8') as f: #只读打开文件 data=f.read() data=data.replace('吴佩其','吴佩其[老男孩第二帅的人]') #置换方法，把吴佩琪换成，逗号后的字符串 with open('user.txt',mode='w',encoding='utf-8') as f: #只写方法打开文件 f.write(data) #把刚刚我们置换好的值，写进去 修改文件方式二： 1、以读的方式打开原文件，以写的方式打开一个新文件2. 在老文件判断找出要修改的字符串修改，并写入新文件
3.最后把老文件删除，并把新文件改名；
import os #导入os 模块
with open('user.txt',mode='rt',encoding='utf-8') as read_f,\ #用只读的方式打开文件user
open('user.txt.swap',mode='wt',encoding='utf-8') as write_f: #用只写的方式打开一个新的文件 。
for line in read_f: #for循环输出老文件里的内容
if '吴佩其' in line: #判断要修改的在不在其中line=line.replace('吴佩其','吴佩其[老男汉特别特别的老]') #在则修改，不在继续循环
write_f.write(line) #不需要修改的写入老文件
os.remove('user.txt') #删除文件
os.rename('user.txt.swap','user.txt') #改文件名；