python数据类型和文件操作
变量创建,垃圾回收机制
name=“lida”
print(id(name)) #内存地址
python解释器有自动垃圾回收的机制,隔一段时间把没有跟变量名关联的内存数据回收(删除)
变量的指向关系
a=‘luoma’
a1=a #a的内存地址给a1,a1内存是直接指向luoma,a1引用了‘luoma’这个变量值
身份运算
>>>b='sub'
>>>type(b) is str
True
>>>type(b) is int
False
==和is之间的区别
Python中对象包含的三个基本要素,分别是:id(身份标识)、type(数据类型)和value(值)
==比较操作符和is同一性运算符区别:
==是python标准操作符中的比较操作符,用来比较判断两个对象的value(值)是否相等
>>> a = 'cheesezh'
>>> b = 'cheesezh'
>>> a == b
True
is也被叫做同一性运算符,这个运算符比较判断的是对象间的唯一身份标识,也就是id是否相同
>>> x = y = [4,5,6]
>>> z = [4,5,6]
>>> x == y
True
>>> x == z
True
>>> x is y
True
>>> x is z
False
>>> print id(x)
3075326572
>>> print id(y)
3075326572
>>> print id(z)
3075328140
三元运算
a=值1 if 条件 else 值2
列表(数组)的增删改查
name=[‘lida’,‘fiona’,‘susan’]
append #追加 name.append(‘eva’)
insert #插入 name.insert(2,‘taylor’)
extend #合并 age=[‘1’,‘3’] name.extend(age)
name.insert(2,[‘aaaaa’,‘bbbbbbb’]) #列表嵌套,读取name[2][1] ---->bbbbbbb
del #直接删除
pop #删除并返回值 name.pop()默认删除末尾元素并返回值;name.pop(1)删除下标1的元素并返回值
clear #清空 name.clear()
remove #从name.remove(‘susan’)左开始匹配删除第一个找到的元素值,如不存在则报错
name[2]=‘jolin’ #修改下标3的元素值
name.index(‘lida’) #查找元素‘lida’,返回从左开始匹配到的第一个lida的索引
name.count(‘lida’) #返回元素值是’lida’的个数
切片
可以同时取出元素的多个值
name=[‘lida’,‘fiona’,‘susan’,‘eva’,‘androw’,‘rob’,‘evelyn’] name[1:4] => [‘fiona’,‘susan’,‘eva’]
语法:name[start:end] (从左往右,顾头不顾尾)star,end可为空,均为空全打印
name[start : end : step] (step 步长) name[1:6:2] ==>[‘fiona’,‘eva’,‘rob’]
(step可为负值,即可实现从右往左)
name[::-1]可起到和name.reverse()一样的效果
排序,循环
name.sort() #排序,list.sort( key=None, reverse=False)
def takeSecond(elem):
return elem[1]
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
random.sort(key=takeSecond)
输出:
[(4, 1), (2, 2), (1, 3), (3, 4)]
for #循环
元组
name(‘lida’,‘fiona’) #元组只读
name(‘lida’,[‘alex’,‘wu sir’],‘rose’) name[1][0]=‘shanben’ —>打印name==>(‘lida’,[‘shanben’,‘wu sir’],‘rose’) #元组本身不可修改,如果元组内含有可变元素,可变元素可以被更改
元组内存的是元素的内存地址
字符串的各种用法
country=‘japanese’
country.count(‘e’) —>2 #e有2个
.center
.endswith
country.find(‘p’) #查找‘p’返回下表,否则返回-1
“{0}{1}”.format(“new york”,“tokyo”) --> new yorktokyo #格式化函数,基本语法是通过 {} 和 : 实现
也可以设置参数:“网站名:{name}, 地址 {url}”.format(name=“菜鸟教程”, url=“www.cool.com”)
.isdigit() #判断是否为数字
.join #拼接字符串 ‘-’.join([‘a’,‘b’,‘n’]) ==>a-b-n
‘china’.ljust(10,‘¥’) ==> china¥¥¥¥¥ #左对齐,不够的"¥"填充
.rjust
‘Nippon’.lower() ==>nippon #小写
.strip() #去除字符串前后的空格
country.replace(“nese”,“XXX”) -->japaXXX #全替换
.split("",max) #字符串切割,max代表切割次数
字典
{"":""}
dict(name=‘name’,age=10)
{}.fromkeys([],value)
增
.setdefault(key,[]) #当key存在时,原value不被更改(安全性好)
删除
.pop("") #指定删除
.popitem() #随机删除
del dict[“fiona”] #指定删除
.clear() #清空dict
修改
dict.update(dict2) #将字典dict2的键值对加进dict,key相同则覆盖
查操作
dict[key] #返回key对应的值,不存在则报错
dict.get(key,default=none) #返回字典中key,不存在则返回default
举例:dict={“name”:“lili”,“age”:“10”,“sex”:“women”}
getVal=dict.get(“favorite”,"-1")
print(getVal) ===> -1
dict.keys() #返回一个包含字典所有key的列表
dict.values() #返回一个包含字典所有value的列表
dict.items() #返回所有键值对元组的列表
循环
for k in dict.keys()
for k,v in dict.items()
for k in dict: print(k,dict[k]) #高效率
集合
set={","","",""}
特点:1,元素不可变,代表你不能存储list,dict在集合里,字符串、数字、元组等不可变类型可存储;2,去重,不能存储重复元素;3,无序,与列表最大的不同是它无法通过索引标记位置,如{1,2,3}和{1,3,2}没有区别; 集合主要可以干两件事:去重和关系运算
语法
set() #转换成集合类
增
.add()
删除
.discard(" “) #删除值,不存在则do nothing不会报错
.pop() #随机删除
.remove(” ") #如果不存在则报错
查
" " in set
关系运算
csdn={“python”,“java”,“php”,“c”,“c#”,“go”,“delphi”}
zhihu={“人生观”,“时事政治”,“吐槽大会”,“python”,“绯闻”,“java”}
print(csdn & zhihu) #交集
print(csdn | zhihu) #并集 or 合集
print(csdn - zhihu) #差集,比较只存在于csdn
print(csdn^zhihu) #对称差集
集合间的三种关系:相交,包含,不相交
csdn.isdisjoint(zhihu) #判断是不是相交,返回bool类型
.issubset #判断是否是子集
.issuperset #判断是否是父集
copy
dict={name:lida…}
dict2=dict,此时dict2和dict是共享同一个数据(列表、字典、集合 等数据类型在内存中可视为一个个的容器,它们也都有一个内存地址;容器里面的元素也都是有内存地址;当有多个变量引用了这些数据类型(相当于共享了容器),其中一个变量更改了其中元素,同时也就共享给其他引用该数据类型的变量)
dict3=dict.copy() #浅copy一个新数据:只copy第一层
import copy #copy.copy( :浅copy ,copy.deepcopy( :深copy
copy.deepcopy(dict) #数据完全从被拷贝数据独立出
二进制
hash(原理)
通过散列算法输出固定长度的散列值,这种转换是一种压缩映射,散列值的空间远小于输入的空间。
特点:不能从结果推算出输入,被称为不可逆算法。密码学、区块链都和哈希有关。
哈希特性:不可逆,计算极快
哈希用途:1,密码:保证同样的输入得出的结果一直一致(生成密文),日常使用的密码
本质都是基于哈希,比如md5加密算法
2,文件的完整性校验:文件大小hash生成一串值,可用它进行校验
3,数字签名:通信双方对暗号。A(私钥) B(公钥)
4,区块链
基于hash的类型:dict
key 唯一
key 不可变
dict的key 经过hash运算
查询速度快不受dict大小影响:key被hash,顺序存进一个列表。拿 dict的key进行hash生成哈希值,可以快速在列表里找到(二分法算法)
set
每存一个值到set,都会先哈希得到hash值,算出在set里的na’ge哪个位置,再检查位置有没有值,如果有不做存储否则就把值存在这
文件操作
1、找到文件 #f= open(filename)
2、读取/修改 #f.read() f.write()
3、保存&关闭 #f.close()
文件打开模式 :三种模式:r read, w write 创建 a append
f=open(file)
循环
for line in f:
print (line)
.seek(int) #设置光标位置;走int个字节(中文是3个字节,如3,6,9,英文是1个字节)
.encoding
.flush #把缓存里的数据强制刷进硬盘里(当往文件write时它不会立刻写进硬盘而是先保存到缓存里,当缓存满了再一起写进硬盘)
.readable #判断文件是否可读
.tell() #返回当前文件的光标位置
.truncate(*args,**kwargs) #指定长度截断文件,指定长度,就从文件开头开始截断长度,不指定就从当前位置,后面全部截掉 (常应用在维护日志)
.writelines(lines)
混合模式
w+ 写读 #创建新文件,可以把写的文件读出来
r+ 读写 #写的文件追加在尾部
a+ 追加读 #文件打开时光标会在文件尾部,写的数据全是追加的形式
修改文件
f=open(path,'r+')
f.seek(int) #移动光标
f.write("马大帅") #修改
*不占内存修改文件
import os
old_file=path
new_file=pathnew
f=open(old_file,"r")
f_new=open(new_file,"w")
old_str="深圳"
new_str="广州"
for line in f:
if "深圳" in line:
line=line.replace(old_str,new_str)
f_new.write(line)
f.close()
f_new.close()
os.replace(new_file,old_file)
读取外部指令
import sys
print(sys.argv)
*StringIO和BytesIOStringIO
StringIO
很多时候,数据读写不一定是文件,也可以在内存中读写。StringIO顾名思义就是在内存中读写str。要把str写入StringIO,我们需要先创建一个StringIO,然后,像文件一样写入即可:
getvalue()方法用于获得写入后的str。
要读取StringIO,可以用一个str初始化StringIO,然后,像读文件一样读取:
BytesIO
StringIO操作的只能是str,如果要操作二进制数据,就需要使用BytesIO。BytesIO实现了在内存中读写bytes,我们创建一个BytesIO,然后写入一些bytes: 写入的不是str,而是经过UTF-8编码的bytes。
和StringIO类似,可以用一个bytes初始化BytesIO,然后,像读文件一样读取:
StringIO和BytesIO是在内存中操作str和bytes的方法,使得和读写文件具有一致的接口。