1、Cpython垃圾回收机制
什么是垃圾：当一个值身上没有人绑定任何变量名（该值的引用计数=0）时，该值就是一个垃圾，会将该值内存空间释放掉。
引用计数增加
age=18 //18的引用计数等于1
x=age //18的引用计数等于2
引用计数减少
age=19 //18的引用计数等于1
del x //解除值与变量名的绑定关系；18的引用计数变为0
2、数据类型介绍
1、 为何数据要分不同的类型？
数据是用来表示状态的，不同的状态就应该用不同的类型的数据去表示
2、数据类型
数字（整形，长整形，浮点型，复数）
字符串
字节串：在介绍字符编码时介绍字节bytes类型
列表
元组
字典
集合
3、按照以下几个点展开数据类型的学习
==========================基本使用============================
1、用途
2、定义方式
3、常用操作+内置的方法
==========================该类型总结==========================
存一个值or存多个值
有序or无序
可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
3、数字
1、整型int
作用：年纪，等级，身份证号，qq号等整型数字相关
定义：age=10 #本质age=int(10)
2、浮点型float
作用：薪资，身高，体重，体质参数等浮点数相关
salary=3000.3 #本质salary=float(3000.3)
类型转换
a=('123') //字符串类型
a=int('123') //字符串转成整型类型
a=float('12.3') //字符串转成浮点型
4、字符串
作用：名字，性别，国籍，地址等描述信息
定义：在单引号\双引号\三引号内，由一串字符组成
类型总结：字符串本质是一个值，但可以按照索引取值，不可变类型类型转换
可以把任意类型转成字符串类型
str(10.3)
str([1,2,3])
str({'x':1})
4.1 需要掌握的操作
切片(顺头不顺尾，步长)
msg='hello world'
print(msg[0]) =h
print(msg[-1]) =d
print(msg[0:5]) =hello
print(msg[0:]) =hello world //步长默认为1
print(msg[:]) =hello world
print(msg[0:5:2]) =hlo //切片方向和步长方向要一致
print(msg[-1:-5:-1]) =dlro
print(msg[::-1]) =dlrow olleh //将字符串倒过来输出统计长度，统计的是字符的个数
print(len(msg)) =11成员运算
print('ho' in msg) =True
print('ho' not in msg) =Falsestrip:移除字符串左右两边的某些字符；lstrip去左边字符；rstarip去右边字符
msg=' hello '
print(msg.strip(' ')) =hello
print(msg.strip()) =hello //strip括号内什么都不写，默认去除的就是空格
name=input('name>>>: ').strip() //输入自动取出两边空格
msg='+-%/hello(+^*'
print(msg.strip('+%/(_+^*')) =hello //指定范围，包括所有符号切分split：把有规律的字符串切成列表从而方便取值;rsplit：从右往左切
info='egon:18:180:150'
res=info.split(':') //以：为分隔符，split两个参数：第一个以...为分隔符，第二个切成几部分
print(res[1]) =18
print(info.rsplit(':',1))字符串的拼接操作join，join的列表里只能是字符串，不能是数字类型
s1=':'.join(res) //创建空字符串，以冒号为分隔符，依次加入列表resstartswith，endswith 判断是否以xx开头，判断是否以xx结尾
msg='alex is dsb'
print(msg.startswith('alex'))
print(msg.endswith('dsb'))format 变量传值 的三种玩法
msg='myname is {name} myage is {age}' .format(age=18,name='abc')
msg1='myname is {name}{name} myage is {age}{age}{age}' .format(age=18,name='abc')
print(msg) =myname is abc myage is 18
print(msg1) =myname is abcabc myage is 181818replace替换
msg='kevin is sb kevin kevin'
print(msg.replace('kevin','sb')) =sb is sb sb sb
print(msg.replace('kevin','sb',1)) =sb is sb kevin kevinisdigit，判断是否为纯数字,小数不是纯数字
print('11111'.isdigit()) =True
res='11111'
print(res.isdigit()) =True
========================以下了解即可========================count 统计个数
msg='kevin is sb kevin kevin'
print(msg.count('kevin')) =3find 找到某个字符，返回值为索引（序列号），返回-1为没找到；rfind 从右边找；与index功能类似，但是没有的字符 index 会报错，没有返回值
msg='xxxkevin is sb kevin kevin'
print(msg.find('kevin')) =3
print(msg.rfind('kevin')) =15center 以某字符居中显示；ljust 居左显示，rjust 居右显示；zfill 用 0 填充
print('egon'.center(50,'')) //50为宽度，以 * 填充
print('egon'.ljust(50,'')) //宽度为50，egon在左边，右边为*
print('egon'.rjust(50,'')) //宽度为50，egon在右边，左边为
print('egon'.zfill(50)) //只有宽度参数，用 0填充，默认字符居右captalize 将首字母大写；swapcase大写转小写，小写转大写；title 单词首字母大写
print('my name is kevin'.captalize()) =My name is kevin
print('AaBbCc'.swapcase()) =aAbBcC
print('my name is kevin'.title()) =My Name Is Kevinis 其它
name='egon123'
print(name.isalnum()) //字符串由字母或数字组成为True，有其它符号为False
print(name.isalpha()) //字符串只由字母组成为True
print(name.islower()) //全是小写为True
print(name.isupper()) //全是大写为True
print(name.isspace()) //全是空格为True
print(name.istitle()) //单词首字母大写为True
4.2 练习
- 写代码,有如下变量,请按照要求实现每个功能 （共6分，每小题各0.5分）
name = " aleX"
1) 移除 name 变量对应的值两边的空格,并输出处理结果
print(name.strip())
2) 判断 name 变量对应的值是否以 "al" 开头,并输出结果
print(name.startswith("al"))
3) 判断 name 变量对应的值是否以 "X" 结尾,并输出结果
print(name.endswith("X"))
4) 将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
print(name.replace("l","p"))
5) 将 name 变量对应的值根据 “l” 分割,并输出结果。
print(name.split("l"))
6) 将 name 变量对应的值变大写,并输出结果
print(name.upper())
7) 将 name 变量对应的值变小写,并输出结果
print(name.lower())
8) 请输出 name 变量对应的值的第 2 个字符?
print(name[1])
9) 请输出 name 变量对应的值的前 3 个字符?
print(name[:3])
10) 请输出 name 变量对应的值的后 2 个字符?
print(name[-2:])
11) 请输出 name 变量对应的值中 “e” 所在索引位置?
print(name.index("e"))
12) 获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。
print(name[:-1])
5、列表
作用：记录多个值
定义方式：在[ ]内用逗号分隔开多个任意类型的值；原材料可以是字符串，列表，字典;可变类型
5.1 优先掌握的操作：
1、按索引存取值(正向存取+反向存取)；可存也可以修改；对于赋值操作必须是已存在的索引
l=['a','b','c','d','e']
print(l[0]) =a
print(l[-1]) =e
l[0]='A' //修改列表
print(l) =['A','b','c','d','e']
2、切片(顾头不顾尾，步长)，步长与字符串一样；原列表不会修改
print(l[1:4]) =['b','c','d']
3、长度
print(len(l)) =5
4、成员运算in和not in
print('a' in l) =True
print('sss' not in l) =True
5、追加&插入
l.append(333) //append最后追加
print(l) =['a','b','c','d','e','333']
l.insert(0,111) //第一个位置添加值
print(l) =['111','a','b','c','d','e']
6、删除remove ，有返回值；del也可删，但是没有返回值；pop 剪切一个值，返回剪切的值
l.remove('a') //()内为值，不能为索引
print(l) =['b','c','d','e']
del l[0] //[ ] 内为索引
l.pop(0) // () 内为索引，不指定索引默认时-1
res=l.pop(0)
print(res) =a
7、循环
for item in l
print(item)
5.2 需要掌握的操作
1、count 统计次数
print(l.count('a')) =1
2、extend 一次性往列表末尾追加多个值，一个参数：可以被 for 循环的列表
item=[1,2,3,4,5]
l.extend(item)
print(l) =['a','b','c','d','e',1,2,3,4,5]
3、index 找索引，以找到的第一个值为准，不存在的值会报错,可以用成员运算判断查找的值是否存在，以避免报错；列表没有find
print(l.index('a')) =0
print(l.index('c',2,5)) =2 //指定查找范围，第二个开始，第五个结束
4、sort 排序，默认从小到大排序
l=[4,6,2,9,10,3,1]
l.sort()
print(l) =[1, 2, 3, 4, 6, 9, 10]
l.sort(reverse=True) //从大到小排序
print(l) =[10, 9, 6, 4, 3, 2, 1]
6、元组
作用：就是一个不可变的列表（是可以当做字典的key的），主要是用来读
定义：在()内用逗号分隔开多个任意类型的元素
t=(1,2,3,('a','b'),['q','w','e'])
本质age=tuple(t=(1,2,3,('a','b'),['q','w','e']))
如果元组只有一个值，必须加一个逗号
t=('a',)
元组总结
1、存多个值
2、有序
3、不可变
6.1 优先掌握的操作
1、按索引取值(正向取+反向取)：只能取，不能添加、减少、修改
t=(1,2,3,('a','b'),['q','w','e'])
print(t[0]) =1
print(t[-1]) =['q','w','e']
2、切片(顾头不顾尾，步长),步长与字符串一致
print(t[1:4]) =(2, 3, ('a', 'b'))
3、长度
print(len(t)) =5
4、成员运算in和not in
print(1 in t) =True
5、循环
for item in t:
print(item)
6.2 需要掌握的操作
t=(1,2,3,('a','b'),3,['q','w','e'])
取索引
print(t.index(3)) =2
print(t.index(3,3,5)) =4 //指定范围，以3开始，以5结束统计个数
print(t.count(3)) =2
7、字典
作用：记录多个值，key对应值，key对value有描述性功能；取值速度快
定义：在{ } 内用逗号隔开多个元素，每个元素都是key:value的形式；key必须是不可变类型，value可以是任意类型
info={'name':'egon','age':18,'sex':'male'}
本质
info=dict(name='egon',age=18,sex='male')
或
info=dict([['name','egon'],('age',18)])
或
{}.fromkeys(('name','age','sex'),None)
总结
1、存多个值
2、无序
3、可变
7.1 优先掌握的操作
1、将值导入字典
第一种方法，必须刚好是两个值
item=[('name','egon'),('age','18'),('gender','male')]
d=dict(item)
print(d) ={'name': 'egon', 'age': '18', 'gender': 'male'}第二种方法，将列表的值导入字典
keys=['name','egon','age','gender','male']
d={}.fromkeys(keys,None) //初始化一个列表，value为None
print(d) ={'name': None, 'egon': None, 'age': None, 'gender': None, 'male': None}
2、按key存取值：可存可取
dic={'name': 'egon', 'age': '18', 'gender': 'male'}
print(dic['name']) =egon //当key不存在时会报错
print(dic.get('name')) =egon
print(dic.get('xxx')) =None //当key不存在时会返回一个None
dic['name']='Egon' //修改value
dic['hight']=18 //如果key不存在，就是一个加值的操作
print(dic) ={'name': 'egon', 'age': '18', 'gender': 'male', 'hight': 18}
3、长度len，统计key:value的个数; 不能有重复的key，后面的key会覆盖前面的key
print(len(dic)) =3
4、成员运算in和not in，以字典的key为准
print('name' in dic) =True
print('dasda' not in dic) =True
5、删除
第一种：del dic['name']
第二种：res=dic.pop('name') //根据key删除，有返回值，返回值为key对应的value值
第三种：res=dic.popitem() //随机删，返回值是(key：value)，返回值格式是元组
6、键keys()，值values()，键值对items()
print(dic.keys()) =dict_keys(['name', 'age', 'gender']) //取索引
print(dic.values()) =dict_values(['egon', '18', 'male']) //取值
print(dic.items()) =dict_items([('name', 'egon'), ('age', '18'), ('gender', 'male')]) //取键值对
7、循环
for item in dic:
print(item) //输出的是key
for item in dic.values():
print(item) //输出的是值
for item in dic.items():
print(ietm) //输出的是 (key:value) 的元组
7.2 需要掌握的操作
1、update 新字典中已经存在的以新的为准，不存在的增加
dic={'name': 'egon', 'age': '18', 'gender': 'male'}
dic.update({'age':19,'hight':180})
print(dic) ={'name': 'egon', 'age': 19, 'gender': 'male', 'hight': 180}
2、setdefault 加入一个键值对，如果key已存在，则保留字典里的原值，如果key不存在，则加入键值对；返回字典里key对应的value值
当key存在时，不改原值，
dic.setdefault('name',’EGON‘)
print(dic) ={'name': 'egon', 'age': '18', 'gender': 'male'}
res=dic.setdefault('name',’EGON‘)
print(res) =egon //返回原值当key不存在时，增加新值，
dic.setdefault('hight',180)
print(dic) ={'name': 'egon', 'age': '18', 'gender': 'male', 'hight': 180}
res=dic.setdefault('hight',180)
print(res) =180
8、集合
作用：关系运算，去重
定义方式：在{ }内用逗号分隔开多个元素，但是元素的特点是
1、每个元素必须是不可变类型(可hash，可作为字典的key)
2、没有重复的元素
3、无序
注意：集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
类型转换
res=set('hello') //字符串转集合
rds=set([1,'a','b']) //列表转集合
print(res) ={'h', 'l', 'e', 'o'} //去重
print(rds) ={1, 'a', 'b'}
总结：
1、有多个值
2、无序
3、可变
8.1 优先掌握的操作
pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}
1、长度len
2、成员运算in和not in
3、合集
print(pythons | linuxs)
4、&交集
print(pythons & linuxs)
5、两个集合差集，以第一个集合为准
print(pythons - linuxs) //求只报名python的学生
print(linuxs - pythons) //求只报名linux的学生
6、对称差集；求没有报名两门课程的学生
第一种：res=(pythons - linuxs) | (linuxs - pythons)
第二种：res=pythons ^ linuxs
print(res)
7、== ，集合值相等即可，无需顺序一致
s1={1,2,3}
s2={3,2,1}
print(s1 == s2) =True
8、父集：>,>= ；子集：<,<=
s1={1,2,3}
s2={3,2,1,4,6}
print(s2 >= s1) =True
print(s1 <= s2) =True
8.2 需要掌握的操作
update 更新
s1={1,2,3}
s1.update({3,4,5,6}) //更新集合，有重复去重
print(s1) ={1, 2, 3, 4, 5, 6}pop 删除，随机删，删除一个
print(s1.pop())remove 指定值删除，没有返回值,不存在的值会报错
s1.remove(1)
print(s1) ={2,3}discard 指定值删除，不存在的值返回None
s1.discard(1)add 添加，无顺序添加
s1.add(4)
print(s1) ={1, 2, 3, 4}去重；
name=['egon','egon','egon','alex','alex','kevin']
res=set(name) //列表导入集合
new_name=list(set(name))
这种方法局限性：
1、只针对不可变类型
2、不能保证原来的顺序
- 用for循环方式去重
new_name=[]
for dic in name:
if dic not in new_name:
new_name.append(dic)
print(new_name) =['egon', 'alex', 'kevin']
9、数据类型总结
按存储空间的占用分（从低到高）
数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改按存值个数区分：
标量／原子类型：数字，字符串
容器类型 列表：元组，字典按可变不可变区分：
可变：列表，字典
不可变：数字，字符串，元组按访问顺序区分：
直接访问：数字
顺序访问（序列类型）：字符串，列表，元组
key值访问（映射类型）：字典
10、字符编码结论
编码与解码
字符编码成 unicode 格式的二进制数存到内存，把unicode格式的二进制数转成其它格式的二进制数刷到硬盘；解码则反过来内存中固定使用unicode编码，我们唯一可以改变的是数据由内存刷到硬盘时采用的编码，应该采用utf-8；
unicode的特点：
1、可以识别万国字符。
2、与各种字符编码的二进制数字都有对应关系。解决乱码问题的核心：
字符当初以什么编码存的，就应该以什么编码去读。因为python2默认ASCII码，python3默认utf-8码； 如果要读gbk编码文件，写文件时要在开头指定#coding:gbk ；其它编码格式一样；如果在文件头指定编码，pycharm文本编辑器会自动转换为指定的编码格式，其它文本编辑器则不会，需要手动修改。
python3中字符串用unicode存在内存当中。python2要在定义字符串前面加个u，意思是字符串指定unicode编码存内存；
例如：x='上' 定义一个字符串；print(x) 打印这一步是将x指向的那块新的内存空间（非代码所在的内存空间）中的内存，打印到终端；python3什么都不用做，python2需要这样定义：x=u'上'
11、文件处理
介绍：计算机系统分为：计算机硬件，操作系统，应用程序三部分。
1、什么是文件？
文件是操作系统为应用程序或者用户提供一种操作硬盘的虚拟单位。
window系统默认为GBK编码
- 强调：
文件是操作系统提供的虚拟单位
应用程序或者用户对文件的读写操作其实都是向操作系统发送指令
2、为什么要用文件？
文件对应的硬盘空间，如果需要考虑永久保存数据那必须使用文件
3、如何用文件？
（1）打开文件
f=open(r'D:\untitled1\a.txt',mode='r',encoding='utf-8')
第一个小r，表示原生的字符串，\没有转义的意思，防止\a、\n转义
第二个小r，以读的模式打开，rb以二进制格式读，rt会把文本文件二进制解码成unicode格式存到内存，针对文本文件用rt模式；w为写操作；
赋值给一个变量，变量指定该文件对象，文件对象占的是应用程序的资源
（2）读/写文件
f.read() //不适合读大文件
强调：在t模式下read(n)，代表字符个数，除此以外的模式都是以字节为单位
f.write()
f.readable() //是否可读
f.writeable() //是否可写
f.readlines() //将文件以列表的方式显示，列表每一个元素，就是文件的每一行；也不适合大文件
f.writelines() //取出列表每个元素，连续写入；括号内为列表变量名
f.flush() //立刻将文件内容从内存刷到硬盘
f.readline() //一次读一行
#例：一行一行读 f 文件
with open('a.txt',mode='rb') as f:
for line in f:
print(line)
（3）关闭文件
f.close() //向操作系统发送指令，让操作系统关闭打开的文件，回收操作系统资源
- 上下文管理
with 在文件读写完，会自动关闭文件；f.close()
with open('a.txt',mode='rt',encoding='utf-8') as f:
data=f.read()
print(data)
---------------------------------------------------------------------
你好哈哈哈
hello
# 也可以打开多个文件，\表示下一行显示，但并不换行
with open('a.txt',mode='rt',encoding='utf-8') as f,\
open('a.txt',mode='rt',encoding='utf-8') as wj:
11.1 文件的解码与编码
x='上'
#unicode的二进制----->编码encode----->gbk格式的二进制
res=x.encode('gbk')
print(res,type(res))
b'\xc9\xcf' <class 'bytes'> //res打印出来是gbk二进制格式，类型为type类型
#unicode的二进制<-----解码encode<-----gbk格式的二进制
m=res.decode('gbk')
print(m)
上
11.2 文件操作模式
1、控制文件读写操作模式
r 只读模式，以该模式打开文件，当文件不存在时报错；
w 只写模式，如果该文件存在则覆盖，如果该文件不存在，创建新文件写入；文件打开不关闭的情况下，连续写入自动追加；
a 追加，如果该文件存在则文件结尾追加内容，如果该文件不存在，创建新文件写入；
w+ 读写，如果该文件存在则覆盖，如果该文件不存在，创建新文件写入
2、控制文件读写内容的模式（不能单独使用，必须与r、w、a连用）
t （默认） 读写只能是文本文件，都是字符串类型,会自动解码文本文件；必须指定encoding参数
b 对于非文本文件，我们只能使用b模式，linux可忽略；"b"表示以字节的方式操作；以b方式打开时，读取到的内容是byte字节类型，写入时也需要提供字节类型，不能指定编码
with语句
为了避免打开文件后忘记关闭，可以通过管理上下文，即：
with open('log','r') as f:
3、文件的修改
- 方式一：
1、以读的方式打开源文件
2、将文件内容一次性全读入内存，在内存完成修改
3、以写的方式打开源文件，然后将修改后的结果一次性写入源文件，再由内存覆盖到硬盘
优点：在文件修改过程中硬盘只存在一份数据
缺点：浪费内存
with open('a.txt',mode='rt',encoding='utf-8') as f1:
msg=f1.read()
new_msg=msg.replace('alex','大SB')
with open('a.txt',mode='wt',encoding='utf-8') as f2:
f2.write(new_msg)
- 方式二：
1、以读的方式打开源文件，以写的方式打开一个临时文件
2、读取源文件的一行内容到内存中，将修改的结果写入临时文件，循环往复直到修改完成
3、删除源文件，将临时文件重命名为源文件名
优点：同一时间在内存中只有文件的一行内容，更节省内存
缺点：在文件修改过程中硬盘存在两份数据
应用场景：适合大文件，需要硬盘空间足够
import os
with open('b.txt',mode='rt',encoding='utf-8') as read_f,\
open('.b.txt.swap',mode='wt',encoding='utf-8') as write_f:
for line in read_f:
write_f.write(line.replace('大sB','alex'))
os.remove('b.txt')
os.rename('.b.txt.swap','b.txt')
11.3 文件指针移动
f.seek(3,0) //3指移动的字节数，0是模式
1、三种模式，以字节为单位；只有0模式既可以在t模式下用也可以在b模式下用，而1、2两种模式只能在b模式下用
0 （默认模式）：永远参照文件开头往后数
1：参照指针当前所在位置
2：参照文件末尾，倒着数
注意：t 模式下的read(n) 是以字符为单位；意思为从哪个字符开始读
b.txt文件内容
你好啊hello
# 0模式
with open('b.txt',mode='rt',encoding='utf-8') as f:
f.seek(3,0)
print(f.tell()) //f.tell() 当前指针位置，永远参照文件开头
print(f.read()) //基于当前所在的位置读
----------------------------
3
好啊hello
# 1模式
with open('b.txt',mode='rb') as f:
f.read(2) //是2个字节
f.seek(4,1)
print(f.read().decode('utf-8')) //从当前字节开始读
-------------------------------
啊hello
#2模式
with open('b.txt',mode='rb') as f:
f.seek(-5,2) //倒着移动5个字节
print(f.tell())
print(f.read().decode('utf-8')) //从当前字节开始读
---------------------------------
9
hello
# 小练习，监测access.log 日志文件，将新增内容输出
with open('access.log',mode='at',encoding='utf-8') as f:
f.write('2011-11-11 11-11-11 alex结婚啦\n') //模拟日志文件；access.log文件追加内容
import time //导入时间模块
with open('access.log',mode='rb') as f:
f.seek(0,2) //指针移到文件末尾
while True:
line=f.readline()
if len(line) == 0:
time.sleep(0.1)
else:
print(line.decode('utf-8'),end='')
12、练习
- 有列表data=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量
data=['alex',49,[1900,3,18]]
a=data[0]
b=data[1]
c=data[2]
print(a,b,c)
- 用列表模拟队列
* 1. 队列：先进先出
l=[]
#入队
l.append('first')
l.append('second')
l.append('third')
print(l)
#出队
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))
- 用列表模拟堆栈
* 堆栈：后进先出
l=[]
#入栈
l.append('first')
l.append('second')
l.append('third')
print(l)
#出栈
print(l.pop())
print(l.pop())
print(l.pop())
- 打印出金字塔
for i in range(0,5):
for j in range(0,4-i):
print(" ",end="")
for k in range(i+1):
print("* ",end="")
print()
for i in range(0,5):
for k in range(i + 1):
print(" ",end="")
for j in range(0, 4 - i):
print("* ",end="")
print()
- 99乘法表
for i in range(1,10):
for j in range(1,1+i):
print("%s * %s = %-2s " % (j , i ,i * j),end="")
print()
