数据类型

单位换算

  • 最小的单位bit,表示一个二进制的0或1,一般使用小写的b表示
  • 存储的最小单位字节(Byte),1B = 8b
  • 1024B = 1KB
  • 1024KB = 1MB
  • 1024MB = 1GB
  • 1024GB = 1TB
  • 1024TB = 1PB
  • 2^32 = 2^10 * 2^10 * 2^10 * 2^2 = 4GB

进制转换

  • 十进制

    • 基数0-9,逢10进1
    • 示例:123 = 1 * 10^2 + 2 * 10^1 + 3 * 10^0 = 100 + 20 + 3 = 123
  • 二进制

    • 基数0和1,缝2进1,python中以’ob’开头
    • 示例:0b110100 = 2^5 + 2^4 + 2^2 = 52
    • 十进制转换二进制:除2取余,倒序书写
      • 22 = 0b10110
  • 八进制

    • 基数0-7,缝8进1,python中以’0o’开头
    • 示例:0o123 = 1* 8^2 + 2 * 8^1+ 3 * 8^0 = 64 + 16 + 3 = 83
    • 八进制转换二进制:八进制1位表示3位二进制
      • 0o123 = 0b 001 010 011
  • 十六进制

    • 基数0-9、A-F,缝16进1,python中以’0x’开头
    • 示例:0xAB = 10 * 16^1 + 11 * 16^0 = 160 + 11 = 171
    • 十六机制转换二进制:十六进制1位表示4位二进制
      • 0xABC = 0b 1010 1011 1100
  • 计算机中的数据是以哪种进制存储的?为什么?

    • 二进制,因为计算机只识别二进制,具体原因如下:
      • 稳定性高(只有0和1)
      • 成本低(技术上容易实现)
      • 与生活中的真假逻辑相吻合
  • 计算机中的数据是如何存储的?

    • 如何存储负数?
      • 最高位为符号位,0表示正数,1表示负数
      • 虽然牺牲了最不常用的最高位,但是解决了负数问题,并简化了硬件设计(节约成本)
      • 示例:(1 + 1) (1 - 1)
        1
        2
        3
        0000 0001                  0000 0001
        0000 0001 1000 0001
        0000 0010 1000 0010 = -2
    • 原码、反码、补码?
      • 正数的三码一致,只有负数才有反码和补码
      • 反码:原码符号位不变,其余位取反
      • 补码:原码的反码加1
      • 计算机中的数据都是以补码的形式存在
    • 示例:
      1
      2
      3
      4
      5
      6
      7
      原码:1000 0001
      反码:1111 1110
      补码:1111 1111
      (1 - 1)
      0000 0001
      1111 1111
      0000 0000 = 0

数据类型

  • 数据类型是为了处理不同的运算而存在的
  • Python中的数据类型有:整型、浮点、字符串、列表、元组、字典、集合、空
  • 整型(int)

    就是数学中的整数
    1
    2
    3
    4
    # 整数
    a = 10
    # 获取变量的类型
    print(type(a))
  • 浮点数(float)

    就是数学中的小数
    1
    2
    3
    4
    5
    6
    7
    # 小数(浮点数)
    b = 3.14
    print(type(b))

    # 科学计数法
    c = 3.14e-3
    print(c)
  • 布尔(bool)

    与生活中的真假逻辑相对应
    1
    2
    3
    # bool类型,只有两个值,True、False
    d = False
    print(type(d))
  • 空(NoneType)

    是一个特殊的类型,只有一个值(None)
    1
    2
    3
    # 空
    e = None
    print(type(e))
  • 字符串(str)

    • 用引号括起来的一串字符
    • 单引号或双引号都可以,也可以使用三个单引号或双引号
    • 单引号中的单引号及双引号中双引号都需要转义
      • 转义字符:换行(\n)、制表(\t)
      • 有时“\”也需要转义
    • 一行显示不完时,换行处理
      1
      2
      3
      4
      5
      6
      7
      # 字符串
      f1 = 'hello'
      f2 = "hello"
      f3 = '''hello'''
      f4 = """hello"""
      print(f3)
      print(type(f4))
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      g = 'hello ' \
      'world'
      print(g)

      h = 'hello \
      world'
      print(h)

      i = '''
      abc
      def
      123
      '''
      print(i)
    • 统计字符个数
      1
      2
      3
      # 无论什么字符,都是一个长度
      s = 'hello你好'
      print(len(s))
    • 字符串拼接
      1
      2
      3
      4
      5
      6
      7
      # 直接拼接
      s2 = 'hello' + 'world'
      print(s2)

      # 指定的字符串重复若干次,然后拼在一起
      s3 = 'abc' * 3
      print(s3)
    • 提取单个字符
      1
      2
      3
      4
      5
      s4 = '123456'
      # 从开头提取,下标从0开始
      print(s4[0])
      # 从末尾提取,下标从-1开始
      print(s4[-1])
    • 字符串切片(提取一段)
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      s5 = 'abcdefg'
      # s[起始下标:结束下标],包括起始下标元素,不包括结束下标元素
      print(s5[0:3])
      # 从开头提取到指定位置
      print(s5[:4])
      # 从指定下标提取到结尾
      print(s5[3:])
      # 从指定位置提取到倒数第一个,不包括倒数第一个
      print(s5[3:-1])
      # 提取最后四个字符
      print(s5[-4:])
      # 提取全部元素
      print(s5[:])
      # 指定步进值,默认为一
      print(s5[::2])
      # 字符串逆序
      print(s5[::-1])
    • 格式化
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      name = 'goudan'
      like = 'wangdahua'
      age = 18

      print('我叫%s,暗恋%s,她今年%d岁了'% (name, like, age))

      # 字符 => ASCII
      print(ord('a'))
      # ASCII => 字符
      print(chr(65))

      print('我叫{},喜欢{},今年{}岁了'.format(name, like, age))
      print('我叫{2},喜欢{1},今年{0}岁了'.format(name, like, age))
      print('我叫{nm},喜欢{lk},今年{a}岁了'.format(nm=name, lk=like, a=age))

      %s:给字符串占位
      %d:给整数占位
      %f:给浮点占位
      %c:给字符占位
      ASCII:
      0-9:48-57
      A-Z:65-90
      a-z:97-122

  • 列表(list)

    • 通过 [] 定义,里边可以存放任意类型的数据
    • 取值:lt[0]lt[-1]
    • 列表是可以修改的,lt[1] = '小敏'
    • 存在越界问题
    • 依然可以进行 +* 运算
    • 也可以进行切片操作
    • lt[:] = [],表示清空列表
    • lt[:2] = [],表示删除前两个元素
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      lt = ['小芳', '小乔', '小王', '小杜', '小韩']
      print(type(lt))
      # 提取元素
      print(lt[0])
      print(lt[-1])
      # 修改元素
      lt[1] = '小敏'
      print(lt)
      #存在越界问题
      print(lt[5])
      # 清空列表
      lt[:] = []
      print(lt)
      # 删除前两个元素
      lt[:2] = []
      print(lt)
  • 元组(tuple)

    • 通过 () 定义,其他操作与列表相同
    • 元组不可修改
    • 当只有一个元素时,元素后边要添加一个逗号
      1
      2
      3
      4
      5
      tu = (123, 456, 789)
      print(tu)
      print(type(tu))
      t = (123,)
      print(type(t))
  • 集合(set)

    • 使用 {} 定义
    • 空集合不能使用大括号来定义(留给字典用的),使用 set() 定义
    • 集合不可修改
    • 集合中的元素是无序的
    • 集合中的元素不能重复
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      s = {'李白', '杜甫', '白居易', '苏轼', '陶渊明'}
      s2 = {'李白', '李商隐', '杜牧', '苏轼'}
      print(s)
      print(type(s))
      # 交集
      print(s & s2)
      # 并集
      print(s | s2)
      # 差集
      print(s - s2)
      # 空集合这样定义,不能使用{}
      s3 = set()
      print(type(s3))
  • 字典(dict)

    • 使用 {} 定义
    • 元素是由键值对组成的
    • 健和值之间使用 : 链接
    • 字典中的键是唯一的,值可以是任意的
    • 字典是可变的
    • 简单使用:
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      d = {'name': '小明', 'age': 18}
      print(d)
      print(type(d))
      # 根据键提取对应的值
      print(d['name'])
      # 键不存在时会报错
      print(d['abc'])
      # 键存在返回对应的值,键不存在返回None,也可以自定义默认值
      print(d.get('name'))
      print(d.get('abc', '默认值'))
      # 没有则添加键值对
      d['hello'] = 'world'
      # 已存在则修改
      d['name'] = 'xiaohua'
      print(d)
      # 删除元素
      del d['name']
      print(d)
      # len返回的是键值对的个数
      print(len(d))
  • 强制类型转换

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    int()   # 转换成整型
    float() # 转换成浮点数
    str() # 转换成字符串
    list() # 抓换成列表
    tuple() # 转化成元组
    set() # 转化成集合
    dict() # 转换成字典

    l = [('name', 'xiaoming'), ('age', 18)]
    print(type(l))
    # 将列表转换成字典
    l1 = dict(l)
    print(l1)
    print(type(l1))
    # 将字典转化成列表,转换后的列表由字典的键组成
    l2 = list(l1)
    print(l2)
    1. 列表去重:列表=>集合=>列表
  • 获取变量的地址

    1
    2
    3
    # 获取变量的地址
    a = 10
    print(id(a))

    不必深究变量的地址问题