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的方法，使得和读写文件具有一致的接口。