整理--数据类型,文件操作

绝对路径和相对路径:

1. 绝对路径:从磁盘根目录开始一直到文件名.

2. 相对路径:同一个文件夹下的文件. 相对于当前这个程序所在的文件夹路径. 如果在同一个文件夹中. 则相对路径就是这个文件名. 如果在上一层文件夹. 则要../

我们更推荐大家使用相对路径. 因为在我们把程拷贝给别人使用的时候. 直接把项目拷贝走就能运行. 但是如果用绝对路径. 那还需要拷贝外部的文件

 

文件操作

追加读(a+)

a+模式下, 不论先读还是后读. 都是读取不到数据的.

with open("S10_Globe_v1.00.txt","a+") as f:
    f.write("aaaaaaaaaa")
    a = f.read()
print(a)    # 打印内容为空

使用seek都是移动到开头或者结尾

通常我们使用seek都是移动到开头或者结尾.

移动到开头: seek(0)

移动到结尾: seek(0,2) seek的第一个参数表示的是从哪个位置进行偏移, 默认是0, 表示开头, 1表示当前位置, 2表示结尾

 

with open("S10_Globe_v1.00_test.conf.src.txt","r+") as f:
    f.write("aaaaaaaaaa")
    a = f.read(10)
    b = f.tell()   #打印光标的位置
print(a,b)    # export tz_ 20     读取是个字符,光标的位置在20,

深坑请注意: 在r+模式下. 如果读取了内容. 不论读取内容多少. 光标显示的是多少. 再写入或者操作文件的时候都是在结尾进行的操作.所以如果想做截断操作. 记住了. 要先挪动光标. 挪动到你想要截断的位置. 然后再进行截断

关于truncate(n), 如果给出了n. 则从开头进行截断, 如果不给n, 则从当前位置截断. 后面的内容将会被删除

 

逻辑运算

　　1, 在没有()的情况下not 优先级高于 and，and优先级高于or，即优先级关系为( )>not>and>or，同一优先级从左往

右计算。

判断下列逻辑语句的True，False

x or y , x为真，值就是x，x为假，值是y；

x and y, x为真，值是y,x为假，值是x。

 

编码

python2解释器在加载 .py 问件中的代码时，会对内容进行编码（默认ascill）,在python3对内容进行编码的默认为utf-8

 

while 条件:

循环体

else: 循环在正常情况跳出之后会执行这句

注意: 如果循环是通过break退出的. 那么while后面的else将不会被执行, 只有在while条件判断是假的时候才会执行这个

else

整数(int)

整数可以进⾏的操作:

bit_length(). 计算整数在内存中占用的二进制码的长度

布尔值(bool)

int => bool bool(int). 0是False 非0是True

bool=>int int(bool) True是1, False是0

str => bool bool(str) 空字符串是False, 不空是True

bool => str str(bool) 把bool值转换成相应的"值"

 

字符串

首字母大写:  ret = s1.capitalize()

大小写转换:  ret = s1.swapcase()

每个被特殊字符隔开的字母首字母大写  ret = s3.title()

可以改变 的长度, 默认长度更改为8

s1 = "alex wusir eggon"

s1.expandtabs()

s11 = "银王哈哈银王呵呵银王吼吼银王"

lst = s11.split("银王") # ['', '哈哈', '呵呵', '吼吼', ''] 如果切割符在左右两端. 那么一

定会出现空字符串.深坑请留意

s1.startswith("sylar")           # 判断是否以sylar开头

s1.endswith("语言.")         # 是否以'语言.'结尾

ret = s1.find("tory")         # 查找'tory'的位置, 如果没有返回-1

ret = s1.index("sylar")              # 求索引位置. 注意. 如果找不到索引. 程序会报错

# 条件判断

s14 = "123.16"

s15 = "abc"

s16 = "_abc!@"

# 是否由字母和数字组成

print(s14.isalnum())

print(s15.isalnum())

print(s16.isalnum())

# 是否由字母组成

print(s14.isalpha())

print(s15.isalpha())

print(s16.isalpha())

# 是否由数字组成, 不包括小数点

print(s14.isdigit())

print(s14.isdecimal())

print(s14.isnumeric()) # 这个比较牛B. 中文都识别.

print(s15.isdigit())

print(s16.isdigit()

负数转成正数

s17 = "-123.12"         s17 = s17.replace("-", "")           # 替换掉负号

s17.count(".") == 1      有小数点=1,表示是小数

 

 元组

元组和元组嵌套

元组: 俗称不可变的列表.又被成为只读列表, 元组也是python的基本数据类型之一, 用小括号括起来, 里面可以放任何数据类型的数据, 查询可以. 循环也可以. 切片也可以. 但就是不能改.

关于不可变, 注意: 这里元组的不可变的意思是子元素不可变. 而子元素内部的子元素是可以变, 这取决于子元素是否是可变对

 

 字典

dic = {"id": 123, "name": 'sylar', "age": 18, "ok": "科比"}
print(dic.items())
for key, value in dic.items():
    print(key, value)
    
# dict_items([('id', 123), ('name', 'sylar'), ('age', 18), ('ok', '科比')])
# id 123
# name sylar
# age 18
# ok 科比

is 和 == 区别

小数据池

            # 数字小数据池的范围  -5 ~ 256
            # 字符串中如果有特殊字符他们的内存地址就不一样
            # 字符串中单个*20以内他们的内存地址一样,单个*21以上内存地址不一致


        is  比较内存地址

                id()   ---- 获取内存地址

                小数据池:

                    数字的小数据池范围是 -5 ~ 256

                    字符串:

                        字符串中不能包含特殊符号   + - * / @ 等等
                        字符串单个字符*20以内内存地址都是一样的,单个字符*21以上内存地址不一致

        注意: pycharm是个坑, 一个py文件中所有相同的字符串 一般都是使用一样的内存地址

        ==  比较俩边的值

将一个列表里面的元素拼接成一个字符串

  

循环删除列表中的每一个元素

l = [11,22,33,44]
for i in l:
    l.remove(i)
print(l)
#[22, 44]

使用

del l[i]

l.pop()

这两个方法同样不行.

分析原因:

for的运行过程. 会有一个指针来记录当前循环的元素是哪一个, 一开始这个指针指向第0个. 然后获取到第0个元素. 紧接着删除第0个. 这个时候. 原来是第一个的元素会自动的变成第0个. 然后指针向后移动一次, 指向1元素. 这时原来的1已经变成了0, 也就不会被删除了

只有这样才是可以的:

#正确实例
for i in range(len(l)):
    l.pop()
print(l)
#  []

 

dict中的fromkey(),可以帮我们通过list来创建一个dict

dic = dict.fromkeys(["jay", "JJ"], ["周杰伦", "麻花藤"])
print(dic)
结果:
{'jay': ['周杰伦', '麻花藤'], 'JJ': ['周杰伦', '麻花藤']}

注意:

dic = dict.fromkeys(["1","2"],["kk","ll"])
print(dic)        #{'1': ['kk', 'll'], '2': ['kk', 'll']}
dic.get("1").append("mm")
print(dic)         #{'1': ['kk', 'll', 'mm'], '2': ['kk', 'll', 'mm']}

代码中只是更改了jay那个列表. 但是由于jay和JJ用的是同一个列表. 所以. 前面那个改了. 后

面那个也会跟着改

dict中的元素在迭代过程中是不允许进行删除的

dic = {'k1': 'aaaa', 'k2': 'bbb', 's1': '⾦⽼板'}
# 删除key中带有'k'的元素
for k in dic:
if 'k' in k:
del dic[k] # dictionary changed size during iteration, 在循环迭
代的时候不允许进⾏删除操作
print(dic)

那怎么办呢? 把要删除的元素暂时先保存在一个list中, 然后循环list, 再删除

dic = {'k1': 'aaaa', 'k2': 'bbb', 's1': '金老板'}
dic_del_list = []
# 删除key中带有'k'的元素
for k in dic:
    if 'k' in k:
        dic_del_list.append(k)
for el in dic_del_list:
    del dic[el]
print(dic)

类型转换

a = (1,2,3,)
b = list(a)  #元组 转 列表
print(b)   #[1, 2, 3]

c = tuple(b)  #列表 转 元组
print(c)  #(1, 2, 3)

e = set(b)    #列表 转 集合
print(e)

f = list(e)    #集合 转 列表
print(f)

b = ["aa","bb","c"]
d = ",".join(b)  #列表 转 成字符串  注意列表的元素一定要是字符串,不能是整数
print(d)

set集合

set中的元素是不重复的.无序的.里面的元素必须是可hash的(int, str, tuple,bool),

set集合中的元素必须是可hash的, 但是set本身是不可hash得. set是可变的.

增加

1 -----s.add("aaa")

2 -----可迭代更新

set1 = {1,2,3}
dict1 = {'name':"BGWAN",'age':22}
set1.update(dict1)
print(set1)  #{1, 2, 3, 'age', 'name'}  去掉了value

set2 = {4,5,6}
set3 = {5,6,7,'890'}
set2.update(set3)
print(set2)    #{4, 5, 6, '890', 7}

s = {"刘嘉玲", '关之琳', "王祖贤"}
s.update("麻花藤") # 迭代更新
print(s)      #{'麻', '关之琳', '王祖贤', '藤', '花', '刘嘉玲'}
s.update(["张曼", "李若彤","李若彤"])
print(s)    #{'李若彤', '麻', '关之琳', '王祖贤', '张曼', '藤', '花', '刘嘉玲'}

这里我们想到一个函数set(),将元素强制集合化，即先将字符串、元组、列表转化成了集合，然后再进行添加更新。要注意的是：非集合元素内容必须是可迭代类型，‘int’类型就不可以，将1放进括号内就会报错。

我们再往深里想，若像列表内又嵌套了列表或集合或元组等类型时会怎么样呢？

set1 = {1,2,3}
list2 = [1,2,(7,9)]    #元组
set1.update(list2)
print(set1)    #{1, 2, 3, (7, 9)}

set = {1,2,3}
list = [[6,5],[9,7]]   #列表
set.update(list)
print(set)  #报错

这里结果会报错，TypeError: unhashable type：list，类型错误，不可拆卸类型,也叫不可哈希。出现这种异常是因为在使用set()过程中，set()传递进来的是不可哈希的元素，而列表嵌套内部由于不分解，要被当做集合内的元素，必须是可哈希的

可哈希的元素有：

int、float、str、tuple

不可哈希的元素有：

list、set、dict，

那么里面嵌套的类型不能是这三种

为什么列表是不可哈希的，而 元组是可哈希的：
（1）因为 list 是可变的，可以在任意改变其内的元素值。
（2）元素可不可哈希，决定是否使用 hash值 进行索引
（3）列表不使用 hash 进行元素的索引，自然它对存储的元素没有可哈希的要求；而 se集合使用 hash 值进行索引。
删除

s.pop() # 随机弹出一个

s.remove("aaa") # 直接删除元素

s = {"11","22","33","44","55","66"}
a = s.pop()   #随机删
print(a)
a = s.pop()
print(a)
s.remove("44")
print(s)    #直接删除元素,如果元素不存在,删除会报错
s.clear()  #清空set集合.需要注意的是set集合如果是空的. 打印出来是set() 因为要和dict区分的.
print(s)    #    set()
print(dic.clear())    #       None          直接清空字典打印的是None

修改

# set集合中的数据没有索引. 也没有办法去定位一个元素. 所以没有办法进行直接修改.

# 我们可以采用先删除后添加的方式来完成修改操作

常⽤操作

s1 = {"aa","bb","cc","dd"}
s2 = {"11","22","33","dd"}

# 交集 ------两个集合中相同的元素
print(s1 & s2)   #    {'dd'}
print(s1.intersection(s2))    #    {'dd'}

# 并集 ----------两个集合的所有元素,去掉重复的
print(s1 | s2)     #      {'11', 'dd', 'aa', 'cc', '22', '33', 'bb'}
print(s1.union(s2))     #      {'11', 'dd', 'aa', 'cc', '22', '33', 'bb'}

#差集------前一个相对于后一个的差集
print(s1 - s2)    #   {'aa', 'cc', 'bb'}    s1 相对于 s2的不同
print(s1.difference(s2))    #   {'aa', 'cc', 'bb'}
print(s2 - s1)     #    {'22', '11', '33'}      s2 相对于 s1的不同
print(s2.difference(s1))        #    {'22', '11', '33'}

# 反交集  ------ 两个集合中单独存在的数据
print(s1 ^ s2)      #    {'11', 'cc', 'bb', 'aa', '22', '33'}
print(s1.symmetric_difference(s2))     #    {'11', 'cc', 'bb', 'aa', '22', '33'}

s3 = {"aa","bb","cc"}
#一个集合是另一个集合的子集
print(s3 < s1)          #    True
print(s3.issubset(s1))     #    True

#超集
print(s1 > s3)      #    True
print(s1.issuperset(s3))       #    True
print(s1 < s3)        #       False
print(s3.issuperset(s1))       #       False

深浅拷贝

 深浅拷贝(难点)
        1. 赋值. 没有创建新对象. 公用同一个对象
        2. 浅拷贝. 拷贝第一层内容. [:]或copy()
        3. 深拷贝. 拷贝所有内容. 包括内部的所有.

赋值

l1 = ["aa","bb","cc","dd"]
l2 = l1
print(l1)          #['aa', 'bb', 'cc', 'dd']
print(l2)          #['aa', 'bb', 'cc', 'dd']
l1.append("11")
print(l1)        #['aa', 'bb', 'cc', 'dd', '11']
print(l2)        #['aa', 'bb', 'cc', 'dd', '11']

dic1 = {"id": 123, "name": "aaa"}
dic2 = dic1
print(dic1)           #{'id': 123, 'name': 'aaa'}
print(dic2)           #{'id': 123, 'name': 'aaa'}
dic1["name"] = "ccc"
print(dic1)         #{'id': 123, 'name': 'ccc'}
print(dic2)         #{'id': 123, 'name': 'ccc'}

对于list, set, dict来说, 直接赋值. 其实是把内存地址交给变量. 并不是复制⼀份内容. 所以.

lst1的内存指向和lst2是一样的. lst1改变了, lst2也发生了改变

浅拷贝

l1 = ["aa","bb","cc","dd"]
l2 = l1.copy()
print(l1)        #         ['aa', 'bb', 'cc', 'dd']
print(l2)        #         ['aa', 'bb', 'cc', 'dd']
print(id(l1),id(l1))       #5896752 5886752   内存地址不一样
# 结果: 
# 两个lst完全不⼀样. 内存地址和内容也不⼀样. 发现实现了内存的拷贝

l1 = ["aa","bb","cc","dd",["11","22"]]
l2 = l1.copy()
l1[4].append("33")
print(l1)     #      ['aa', 'bb', 'cc', 'dd', ['11', '22', '33']]
print(l2)     #      ['aa', 'bb', 'cc', 'dd', ['11', '22', '33']]
print(id(l1[4]),id(l2[4]))    #6567456 6567456  内存地址一样

浅拷贝. 只会拷贝第一层. 第二层的内容不会拷贝. 所以被称为浅拷贝

深拷贝

#深拷贝
import copy
l1 = ["aa","bb","cc","dd",["11","22"]]
l2 = copy.deepcopy(l1)
l1[4].append("333333")
print(l1)            #    ['aa', 'bb', 'cc', 'dd', ['11', '22', '333333']]
print(l2)           #     ['aa', 'bb', 'cc', 'dd', ['11', '22']]
print(id(l1[4]),id(l2[4]))        #     7311568 7312488  不一致

都不一样了. 深度拷贝. 把元素内部的元素完全进行拷贝复制. 不会产生一个改变另一个跟着

改变的问题

 

最后我们来看一下题目:

a = [1,2]
a[1] = a
print(a[1])   #[1, [...]]