zoukankan      html  css  js  c++  java
  • 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

  • 相关阅读:
    【Elasticsearch 技术分享】—— ES 常用名词及结构
    【Elasticsearch 技术分享】—— Elasticsearch ?倒排索引?这都是什么?
    除了读写锁,JUC 下面还有个 StampedLock!还不过来了解一下么?
    小伙伴想写个 IDEA 插件么?这些 API 了解一下!
    部署Microsoft.ReportViewe
    关于TFS强制undo他人check out
    几段查看数据库表占用硬盘空间的tsql
    How to perform validation on sumbit only
    TFS 2012 Disable Multiple Check-out
    在Chrome Console中加载jQuery
  • 原文地址:https://www.cnblogs.com/antigeneral/p/10220849.html
Copyright © 2011-2022 走看看