day6python基础数据补充

1编码转换

1. ASCII : 最早的编码. ⾥⾯有英⽂⼤写字⺟, ⼩写字⺟, 数字, ⼀些特殊字符.没有中⽂, 8个01代码, 8个bit, 1个byte

2. GBK: 中⽂国标码, ⾥⾯包含了ASCII编码和中⽂常⽤编码. 16个bit, 2个byte

3. UNICODE: 万国码, ⾥⾯包含了全世界所有国家⽂字的编码. 32个bit, 4个byte, 包含了 ASCII

4. UTF-8: 可变⻓度的万国码. 是unicode的⼀种实现. 最⼩字符占8位

　　　　1.英⽂: 8bit 1byte

　　　　2.欧洲⽂字:16bit 2byte

　　　　3.中⽂:24bit 3byte

decode:解码

encode:编码

s = '香港'
a = 'wangge'
s1 = s.encode('utf-8')
print(s1)
print(s1.decode('utf-8'))
a1 = a.encode('utf-8')
print(a1)
s2 = s.encode('gbk')
print(s2)
a2 = a.encode('gbk')
print(a2)
s3 =s.encode('utf-8')
print(s3.decode('gbk'))
结果
b'xe9xa6x99xe6xb8xaf'
香港
b'wangge'
b'xcfxe3xb8xdb'
b'wangge'
棣欐腐

用什么方式编码就用什么方式解码.

2基础数据补充(容易犯错的地方)

list 用 for 循环添加元素

lst = [1,2,3,4,5,6]
for i in lst:
    lst.append(7) # 这样写法就会一直持续添加7
    print(lst)
print(lst)

　　每次循环一次,都会在原来的lst里添加一个元素7,这样就会无限的循环下去.

list用for循环删除元素.

li = [11, 22, 33, 44]
for e in li:
 li.remove(e)
print(li)
结果:
[22, 44]

for循环是按下标索引去运行的,第一次运行,删除的11,剩下的列表为[22,33,44],然后第二次运行的是下标是1,e为33,删除掉是33.剩下了44,列表为[22,44].

del也是一样的效果,能行的有pop,或者另外构造一个同样的不改变列表去做.由于删除元素会导致元素的索引改变, 所以容易出现问题. 尽量不要再循环中直接去删 除元素. 可以把要删除的元素添加到另⼀个集合中然后再批量删除

 for i in range(len(li)):      # 行
     li.pop()
 print(li)

 li = [1,2,3,4,5]              # 行
 l2 = []
 for i in li:
     l2.append(i)
 for j in l2:
     li.remove(j)
 print(li)

dict中的元素在for迭代过程中进⾏删除

 dic = {'1':22,'5':'22'}
 for i in dic:
     dic['6'] = 1
 print(dic)

# dictionary changed size during iteration, 在循环迭

代的时候不允许进⾏删除操作

把要删除的元素暂时先保存在⼀个list中, 然后循环list, 再删除

 lst = []
 for i in dic:
     lst.append(i)   # 每个字典的键
 for j in lst:
     dic.pop(j)
 print(dic)

dict中的fromkey(),深坑!

 dic = dict.fromkeys('年后啊','消愁')

 第一个位置是可迭代对象,也就是字典的键
 第二个位置 不写是None  也就是字典的值

 print(dic)
 dic['年'] = '今天老子不上班'   # 字符串不能修改
 print(dic)

 dic['你'] = [5,6,7]
 print(dic)
 dic = dict.fromkeys('你好啊',[1,2,3])
 print(dic)
 dic['你'].append(99)
 print(dic)

输入结果:

{'年': '消愁', '后': '消愁', '啊': '消愁'}
{'年': '今天老子不上班', '后': '消愁', '啊': '消愁'}
{'年': '今天老子不上班', '后': '消愁', '啊': '消愁', '你': [5, 6, 7]}
{'你': [1, 2, 3], '好': [1, 2, 3], '啊': [1, 2, 3]}
{'你': [1, 2, 3, 99], '好': [1, 2, 3, 99], '啊': [1, 2, 3, 99]}

当第二个位置字典的值是可变的数据类型时,因为可变内存地址是在原内存地址上修改的,所以全部的字典值都发生了变化.

类型转换:

　　元组 => 列表 list(tuple)

　　列表 => 元组 tuple(list)

　　list=>str str.join(list)

　　str=>list str.split()

　　转换成False的数据:

　　 0,'',None,[],(),{},set() ==> False　

s = '1'
i = int(s)  # 数字1    #只能转引号里边是数字的字符串

o = 1
ss = str(o) # 字符串1  # 不用注意

num = int(True)  # 1   把布尔值转成数字
bool(1)   #    只要是非0的都是True

ss = str(True)  # "True"
bool('')  #  只要字符串是非空的就是True

3:深浅拷贝

 1)首先是赋值跟copy的区别

li = [1,2,3,4]
lst = li
print(li)
print(lst)
li[0] = 56
print(li)   # 变
print(lst)  # 变

而且id(lst)=id(li) 赋值是完全相同的元素内容以及内存地址.

copy(浅拷贝)

 li = [1,2,3,4]
 lst = li.copy()
 print(li)
 print(lst)

 print(id(li))   # 34512776
 print(id(lst))  # 34512840

 li[0] = 56
 print(li)   # 变
 print(lst)  # 不变

当列表的第一层都是不可变数据时,只要对原列表进行更改,不可变数据会开辟一个新的内存地址指向元素,而不是在原内存地址上修改,所以copy的那个lst是不变的.

# print(id(li[0]))  # 1548382960
# print(id(lst[0])) # 1548381200

# print(id(li[1]))  # 1548381232
# print(id(lst[1])) # 1548381232

当元素里有可变数据时:

 li = [1,2,3,4,[5,6,7]]    # 浅拷贝只拷贝一层元素
 lst = li.copy()
 print(li)
 print(lst)

 li[-1].append(90)
 print(li)   # 变
 print(lst)  # 变

 print(id(li[-1]))
 print(id(lst[-1]))

结果:
[1, 2, 3, 4, [5, 6, 7]]
[1, 2, 3, 4, [5, 6, 7]]
[1, 2, 3, 4, [5, 6, 7, 90]]
[1, 2, 3, 4, [5, 6, 7, 90]]
1904133805768
1904133805768

深拷贝:

import copy

 li = [1,2,3,4,[5,6,7]]

 lst = copy.deepcopy(li)

 print(id(lst[-2]))   # 39584432
 print(id(li[-2]))    # 39570288

深度拷贝. 把元素内部的元素完全进行拷贝复制. 不会产⽣⼀个改变另⼀个跟着 改变的问题.不可变数据类型共用一个内容,可变数据(列表跟字典)类型重新开辟空间存放内容

面试题:

# li = [1,2] # li = [1,[1,[1,[1,2]]]]
# li[1] = li
# print(li)
# 结果 [1, [...]]

is 与 ==的区别:

 a = 1000
 b = 1000
 print(a == b)
 print(id(a))
 print(id(b))
 print(a is b)   # is 是

  ==  比较两边的值            # 看这俩人是不是长得一样
 is   比较两边的内存地址      # 判断是不是一个   身份证号

代码块

def func():
a = 'asd@fasdf'* 20
print(id(a))
def func1():
b = 'asd@fasdf'* 20
print(id(b))
print(func(),func1())

a = 100000000
b = 100000000
c = 100000000
d = 100000000

一个文件就是一个代码块:

print(a is b) # 节省资源

代码块机制:

数字: -5 ~ 256
字符串: 乘法的时候总长度不能超过20

代码块 > 小数据

s = '222222222222222222222222222222222222222222222222222222'
f = '222222222222222222222222222222222222222222222222222222'

print(s is f)

s = 'asdsr' * -50
d = 'asdsr' * -50
print(s is d)

a = '12221341asdfadsfasxzvdasfasdfewfwfvxasgfrqegvewrgavrgvaerg'
b = '12221341asdfadsfasxzvdasfasdfewfwfvxasgfrqegvewrgavrgvaerg'

a = '@'* 2
b = '@'* 2