• day07 基础数据类型补充


    day07 基础数据类型补充

    今日内容概要

    1. 基础数据类型
    2. 循环删除的坑
    3. 二次编码

    上周内容回顾

    1. 驻留机制
      • 小数据池
        • 数字:-5 ~ 256
        • 字符串:定义和乘法操作时均不能有中文或字符
          • Python 3.6版本乘法操作结果最大长度为20
          • Python 3.7版本乘法操作结果最大长度为4096
        • 布尔值
      • 代码块
        • 数字:-5 ~ 正无穷
        • 字符串:乘法操作时均不能有中文或字符,定义时可以有
          • 乘法操作结果最大长度为20
        • 布尔值
        • 代码块的优先级高于小数据池
        • 代码块:一个py文件,一个模块,一个类,一个函数,交互模式下的每一行代码
    2. 深浅拷贝
      • 赋值:多个变量名指向同一个内存地址
      • 浅拷贝:只拷贝最外层元素的内存地址
      • 深拷贝:不可变数据共用,可变元素新开辟内存空间
      • ==:用于判断两边的值是否相等
      • is:用来判断两边的内存地址是否相同
    3. 集合
      • set,天然去重
      • 集合是一个没有值的字典
      • 集合增加:add,update
      • 集合删除:pop,remove,clear
      • 集合的修改:先删后加,改为其他数据类型
      • 集合的查看:for循环
      • 集合关系:
        • 交集:&
        • 并集:|
        • 差集:-
        • 补集(反差集,对称差集):^
        • 父集:>
        • 子集:<

    今日内容详细

    基础数据类型补充

    整型

    .bit_length方法用来计算整型数字转换为二进制所占的位数:

    a = 10
    print(a.bit_length())
    
    输出的结果为:4
    

    这个方法的意思是,10转换为二进制数时1010,一共会占4位。

    字符串

    .capitalize()方法用来将字符串的首字母大写:

    s = 'alEX wusir'
    s1 = s.capitalize()
    print(s1)
    
    输出的结果为:Alex wusir
    

    .title()方法能将字符串每个单词的首字母大写,区分首字母的方式有空格、符号和数字等:

    s = 'alEX wUsir-meET3san'
    s1 = s.title()
    print(s1)
    
    输出的结果为:Alex Wusir-Meet3San
    

    .index()方法用来通过元素查找索引,查找不到时会报错:

    s = 'alex wusir'
    print(s.index('e'))
    

    .find()方法同样用来通过元素查找索引,与.index()方法不同的是,.find()方法查找不到时会返回-1,而不会报错:

    s = 'alex wusir'
    print(s.find('b'))
    

    .center()方法用来进行居中操作,会在字符串两端插入等量的空格,使得字符串总长度等于输入的参数:

    s = 'alex wusir'
    print(s.center(20))
    

    也可以指定两端填充的内容:

    print(s.center(20, '-'))
    
    输出的结果为:-----alex wusir-----
    

    .format()方法是另外一种字符串格式化的方法:

    s = 'alex{}wu{}si{}r'
    s1 = s.format('你好', '我好', '大家好')
    print(s1)
    
    输出的结果为:alex你好wu我好si大家好r
    

    .format()方法除了向上面这种按照位置格式化之外,还可以按照索引格式化:

    s = 'alex{0}wu{2}si{1}r'
    s1 = s.format('你好', '我好', '大家好')
    print(s1)
    
    输出的结果为:alex你好wu大家好si我好r
    

    .format()方法还可以按照关键字进行格式化:

    s = 'alex{a}wu{c}si{b}r'
    s1 = s.format(b = '你好', a = '我好', c = '大家好')
    print(s1)
    
    输出的结果为:alex我好wu大家好si你好r
    

    .swapcase()方法可以反转字符串中字母的大小写:

    s = 'alEx'
    s1 = s.swapcase()
    print(s1)
    
    输出的结果为:ALeX
    

    这里插入一个PyCharm的使用技巧:ctrl + shift + r打开替换窗口。

    列表

    对列表进行反转操作,我们可以通过切片的方式进行:

    lst = [1, 2, 3, 4, 5, 6]
    print(lst[::-1])
    

    这种方法并没有对原来的列表进行修改,而是创建了一个新列表。如果我们想对原来的列表进行改动,可以将切片后的结果赋值给lst。也可以使用.reverse()的方法,对列表本身进行原地的反转操作:

    lst = [1, 2, 3, 4, 5, 6]
    lst.reverse()
    print(lst)
    
    输出的内容为:[6, 5, 4, 3, 2, 1]
    

    列表的.sort()方法可以将混乱的列表排序,默认是按照升序排序:

    lst = [2, 1, 3, 4, 6, 5]
    lst.sort()
    print(lst)
    
    输出的结果为:[1, 2, 3, 4, 5, 6]
    

    我们可以混合使用reverse方法将升序的列表反转,达到降序的目的。也可以通过将.sort()方法中的参数reverse设置为True,来让列表进行降序排序:

    lst = [2, 1, 3, 4, 6, 5]
    lst.sort(reverse=True)
    print(lst)
    
    输出的结果为:[6, 5, 4, 3, 2, 1]
    

    .index()方法通过元素名来查找该元素在列表中的索引:

    lst = [1,2,3,4,6,5]
    print(lst.index(4))
    
    输出的结果为:3
    

    需要注意的是,如果需要查询的元素在列表中不止一个,.index()方法只会返回从左面数第一个元素的索引值:

    lst = [1,2,3,4,4,6,5]
    print(lst.index(4))
    
    输出的结果仍然是:3
    

    跟字符串类似,列表也可以进行加法和乘法的操作:

    lst1 = [1, 2, 3, [4]]
    lst2 = [4, 5, 6]
    print(lst1 + lst2)
    print(lst2 * 3)
    
    输出的结果为:
    [1, 2, 3, [4], 4, 5, 6]
    [4, 5, 6, 4, 5, 6, 4, 5, 6]
    

    需要注意的是,列表的加法和乘法都是新开一个空间存储结果,而不是对原列表进行操作。但是加法和乘法的结果所使用的元素仍然是原列表中的。相应的操作与浅拷贝就很类似了:

    lst1 = [1, 2, 3, [4]]
    lst2 = [4, 5, 6]
    l_sum = lst1 + lst2
    l_sum[3].append(9)
    print(lst1, lst2, l_sum)
    l_multi = lst1 * 2
    l_multi[3].append(8)
    print(lst1, lst2, l_multi)
    
    输出的结果为:
    [1, 2, 3, [4, 9]] [4, 5, 6] [1, 2, 3, [4, 9], 4, 5, 6]
    [1, 2, 3, [4, 9, 8]] [4, 5, 6] [1, 2, 3, [4, 9, 8], 1, 2, 3, [4, 9, 8]]
    

    元组

    元组需要补充的内容不是很多,只是需要掌握下面这三种小括号的含义即可:

    tu = (10)    # int,括号中只有一个元素且没有任何逗号,那就表示该元素本身。此时,括号可以看成一个运算符。
    tu = (10,)    # tuple,括号中虽然只有一个元素,但是元素后面有一个逗号,表示这是一个元组。
    tu = ()    # tuple,这时空元组的表示方法,括号中什么都没有。
    

    字典

    .fromkeys()方法用来批量创建键值对,此方法需要两个参数,参数1是一个可迭代对象,将会迭代添加到字典中成为键,参数2是这些键共用的值:

    dic = {'key': 1, 'key1': 2}
    dic1 = dic.fromkeys('abc', 12)
    print(dic,dic1)
    
    输出的结果为:{'key': 1, 'key1': 2} {'a': 12, 'b': 12, 'c': 12}
    

    这里需要注意的是,.fromkeys()方法并不是修改字典的方法,而是会创建一个新字典并返回。

    另外一个需要注意的是,如果参数2是可变数据,所有的值会共用这个数据:

    l = []
    dic = dict().fromkeys('abc', l)
    l.append(2)
    print(l, dic)
    
    输出的结果为:[2] {'a': [2], 'b': [2], 'c': [2]}
    

    表示False的方法:

    所有数据类型,只要是空的,就是False,否则就是True。

    False
    print(bool(0))
    print(bool())
    print(bool(None))
    print(bool(""))
    print(bool([]))
    print(bool(()))
    print(bool({}))
    print(bool(set()))
    

    类型转换

    tuple(list)
    list(tuple)
    
    set(list)
    list(set)
    
    set(tuple)
    tuple(set)
    
    int(str)  # 字符串中必须全部都是阿拉伯数字
    str(int)
    
    s1 = "".join('列表','元组')    # 将列表转换成字符串   ****
    s.split(":")              # 将字符串转化成列表   ****
    
    str(dict)
    str(list)
    str(tuple)
    str(int)
    str(set)
    str(bool)
    

    基础数据类型总结

    数据类型 有序无序 是否可变 可否迭代 查看方式
    int 有序 不可变 不可迭代 直接查看
    bool - 不可变 不可迭代 直接查看
    str 有序 不可变 可迭代 通过索引查看
    tuple 有序 不可变 可迭代 通过索引查看
    list 有序 可变 可迭代 通过索引查看
    dict 无序 可变 可迭代 通过键查看
    set 无序 可变 可迭代 for循环查看

    循环删除的坑

    有这样一个列表:lst = [11, 22, 33, 44, 55],现在我们想要把列表中的每个元素都删除掉,但是不能用.clear()方法。我们很理所当然地会想到使用for循环逐个删除:

    lst = [11, 22, 33, 44, 55]
    for i in lst:
        lst.remove(i)
    print(lst)
    
    输出的结果为:[22, 44]
    

    居然没有删除干净。

    这是python中循环的自主计数和列表的自动补位共同影响下的结果。在循环第一圈时,循环操作从索引值为0的位置找元素,返回了11,被成功删除。当列表删除了11之后,后面的元素会自动补位上来,此时,22的索引变成了0,33的索引变成了1。随后,进入第二圈循环,循环操作会自主把计数加一,开始找索引值为1的元素,也就是33,被成功删除,而22,被忽略掉了。如此一来,所有偶数索引的元素都被删除,奇数索引的元素被保留下来。

    为了应对这种循环删除的坑,我们可以采取两种方式[1]

    方式一,使用range获取字符串长度,控制循环次数,保证能够完全删除:

    lst = [11, 22, 33, 44, 55]
    for i in range(len(lst)):
        lst.pop()
    print(lst)
    

    方式二,通过复制一个列表,通过循环复制过的列表,控制循环次数:

    lst = [11, 22, 33, 44, 55]
    for i in lst.copy():
        lst.remove(i)
    print(lst)
    

    除了列表之外,字典和集合也深受循环删除的坑的困扰。与列表不能删除干净不同的是,字典和集合在迭代过程中是不可以修改字典的长度的,一旦有修改,就会报错。也就是说,一旦在迭代过程中删除键值对,程序会直接报错:

    dic = {"key":1,"key2":2}
    for i in dic:
        dic.pop(i)
    print(dic)
    
    运行后报错:
    Traceback (most recent call last):
      File "C:/Users/Sure/PyProject/day07/01 exercise.py", line 88, in <module>
        for i in dic:
    RuntimeError: dictionary changed size during iteration
    

    同样地,我们也可以通过复制一份字典,然后通过迭代新的字典来删除原字典中的键值对:

    dic = {"key":1,"key2":2}
    for i in dic.copy():
        dic.pop(i)
    print(dic)
    

    二次编码

    编码回顾

    ascii : 英文,数字,符号
        英文: 1个字节,8位
    
    gbk   : 英文,数字,符号,中文
        英文: 1个字节,8位
        中文: 2个字节,16位
    
    unicode : 英文,数字,符号,中文
        英文: 4个字节,32位
        中文: 4个字节,32位
    
    utf-8 : 英文,数字,符号,中文
        英文: 1个字节,8位
        欧洲: 2个字节,16位
        亚洲: 3个字节,24位
    

    在python 3的内存中使用的是Unicode编码,而硬盘中存储时使用的是选择的编码方式[2]。这样一来,就需要进行Unicode和其他编码方式的转变,也就涉及到编码和解码的问题。

    编码是将字符转化为二进制的形式,使用的是.encode()方法:

    s = "你好"
    s1 = s.encode("utf-8")       # 编码
    print(s1)
    
    输出的内容为:b'xe4xbdxa0xe5xa5xbd'
    

    解码是将二进制形式的数据转换成位符,使用的是.decode()方法:

    s = b'xe4xbdxa0xe5xa5xbd'
    s2 = s.decode('utf-8')
    print(s2)
    
    输出的内容为:你好
    

    需要注意的是,用什么方式进行编码,就需要用什么方式进行解码。解码方式使用错误,轻则乱码,重则报错。

    编码的用处主要在两个方面:

    1. 存储,涉及到文件操作
    2. 传输,涉及到网络编程

    1. 应对方法不止这两种,可以任意开发 ↩︎

    2. 对于中文来说,主要是gbk和utf-8 ↩︎

  • 相关阅读:
    页面检测网络外网连接- 网页基础模块(JavaScript)
    sql server替换字段中的某个字符
    关于Linux下 fork() 函数的总结
    郁闷的一天
    关于 Linux 下的线程函数未定义问题
    英文书籍
    学会阅读外文资料
    内存池设计(五)
    内存池设计(四)
    内存池设计(三)
  • 原文地址:https://www.cnblogs.com/shuoliuchina/p/11538392.html
Copyright © 2020-2023  润新知