Python基础:数据类型

数据类型

进制转换

• 十进制：

  • 基数0~9，逢10进1

  • 示例：123 = 1 * 10^2 + 2 * 10^1 + 3 * 10^0 = 100 + 20 + 3 = 123

• 二进制：

  • 基数0和1，逢2进1

  • 示例：0b110100 = 2^5 + 2^4 + 2^2 = 32 + 16 + 4 = 52

  • 十进制转二进制：除2取余，倒序书写

    • 22 = 0b10110

• 八进制：

  • 基数0~7，逢8进1

  • 示例：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

  • 示例：0xAB = 10 * 16^1 + 11 * 16^0 = 160 + 11 = 171

  • 十六进制转二进制：十六进制的1位可以表示4位二进制数

    • 0xABC = 0b 1010 1011 1100

• 计算机中的数据是以哪种进制存储的？为什么？

  • 二进制，因为计算机设计时只能识别二进制。具体原因：

  • 稳定性高(0和1)、成本低(技术上容易实现)、与真假逻辑相对应(便于解决生活中的实际问题)

• 计算机中的数据是如何表示的？

  • 只保留加法器，去掉减法器，负数如何表示？

    • 最高位作为符号位：0表示正数，1表示负数

    • 虽然牺牲了最高位，但是解决了负数的表示问题，简化了硬件设计，节约了成本。

  • 原码反码和补码：是针对负数而言的(正数的三码一致)

    • 负数的反码等于原码的符号位不变，数据位取反

    • 负数的补码等对应的反码加1

  • 计算机中的数据是以补码的形式存储的。

数据类型

• 说明：编程语言的不同数据类型都是为了解决实际问题而出现的

• python中常见的数据类型：整型、浮点、布尔、字符串、列表、元组、集合、字典等

• 整型(int)：就是数学中的整数

• 浮点(float)：就是数学中的小数

• 复数(complex)：了解

  # 整型
  a = 250
  ​
  print(a)
  # type：获取变量的类型
  print(type(a))
  ​
  # 浮点
  b = 3.14
  print(b, type(b))
  ​
  # 科学计数法
  c = 3.1415e-3
  print(c)
  ​
  # 复数
  d = 3 + 4j
  print(d, type(d))

   

• 布尔(bool)：对应生活中的真假逻辑，只有两个值True/False

• 空(NoneType)：空类型，只有一个值None

  # 布尔
  # a = True
  a = False
  ​
  print(a, type(a))
  ​
  # 空
  b = None
  print(b, type(b))

   

• 字符串(str)：使用引号括起来的一串字符

  • 定义：一对单引号或双引号、三对单引号或双引号

  • 转义：使具有特殊意义的字符失去原有的意义，变成普通字符

  • 特殊字符：'\n'、'\r'、'\t'

  • 原始字符：在定义字符串前加一个字符'r'，其中的所有字符都是普通字符

• 列表(list)：通过[]进行定义，可以存储一系列的任意数据，是容器类型

  # 列表
  lt = [1, 'abc', 3.14]
  print(lt, type(lt))
  # 通过下标访问元素，下标从0开始
  print(lt[0])
  # 存在越界问题，会报IndexError的错误
  # print(lt[3])

   

• 元组(tuple)：通过()进行定义，可以存储一系列的任意数据，但是元素是不可修改的

  # 元组
  # tp = (1, 2, 3)
  # tp = 1, 2, 3
  # 定义只有一个元素的元组，不要忘记添加一个逗号
  tp = (1,)
  print(tp, type(tp))
  # 也是通过下标访问元素
  # print(tp[0])

   

• 集合(set)：通过{}进行定义，也是容器对象，可以存储任意类型的数据，但是元素不能重复，无序

  # 集合
  s1 = {'小芳', '小敏', '小马', '小乔'}
  s2 = {'小杜', '小敏', '小王'}
  ​
  print(s1, type(s1))
  # 交集
  print(s1 & s2)
  # 并集
  print(s1 | s2)
  # 差集
  print(s1 - s2)
  print(s2 - s1)
  ​
  # 定义空集合不能使用{}，它是留给定义空字典使用的
  # s3 = {}
  # 这样可以定义空集合
  s3 = set()
  print(s3, type(s3))

   

• 字典：通过{}进行定义

  • 元素是由键值对构成的

  • 键和值之间通过':'连接

  • 键是唯一的，值是任意的

  • 字典中的键值对是可以更改的

  • 示例：

  # 字典
  d = {'name': 'ergou', 'age': 18}
  print(d, type(d))
  # 根据键获取值
  print(d['name'])
  ​
  # 当字典中没有对应的键，会报KeyError错
  # print(d['height'])
  ​
  # 键存在就返回对应的值，不存在返回None
  print(d.get('height'))
  # 不存在默认返回None，但是可以指定默认值
  print(d.get('weight', 80))
  ​
  # 统计字典元素个数，统计的是键值对的个数
  print(len(d))
  print(len(lt))
  print(len(tp))
  print(len(s1))
  # 统计字符串长度
  print(len('hello'))

   

类型转换

• 隐式类型转换：混合运算、条件判断等

• 强制类型转换：使用专门的转换函数

  • 函数

  int:转换为整型，base参数用来指明参数的进制类型
  float:转换为浮点数
  str:转换为字符串
  list:转换为列表
  tuple:转换为元组
  set:转换为集合
  dict:转换为字典

  • 示例：

  # 转换为整型
  a = int(3.14)
  print(a, type(a))
  ​
  # base：指明参数的进制类型
  b = int('123', base=16)
  print(b)
  ​
  # bool类型也可以转换
  print(int(False))
  ​
  # 转换为浮点数
  c = float(250)
  print(c, type(c))
  ​
  # 转换为字符串
  d = str(123)
  print(d, type(d))
  ​
  # 转换为列表
  e = list('hello')
  e = list((1, 2, 3))
  e = list({1, 2, 3})
  # 字典也可以转换为列表，但是只保留了键
  e = list({'name': 'dahua', 'age': 18})
  print(e, type(e))
  ​
  # 转换为元组
  f = tuple('world')
  f = tuple([1, 2, 3])
  print(f, type(f))
  ​
  # 转换为集合
  g = set([1, 2, 3, 1])
  print(g, type(g))
  ​
  # 转换为字典
  lt = [('name', 'dahua'), ('age', 18)]
  h = dict(lt)
  print(h, type(h))

   

字符串操作

• 常规操作

  s1 = 'hello'
  s2 = 'world'
  ​
  # '+'可以直接将字符串拼接在一起
  print(s1 + s2)
  ​
  # '*'可以将指定的内容重复指定次数
  print(s1 * 3)
  ​
  # len：可以统计字符串长度
  print(len(s1))
  ​
  # 从开头进行提取，下标从0开始
  print(s1[0])
  # 从末尾进行提取，下标从-1开始
  print(s1[-1])
  ​
  # 切片操作
  s = '123456789'
  # 包括起始下标，不包括结束下标，步进值为1，[起始，结束)
  print(s[2:5])
  ​
  # 省去边界将提取到该边界
  print(s[:3])
  print(s[3:])
  print(s[:])
  ​
  print(s[1:-2])
  print(s[-3:])
  print(s[:-3])
  ​
  # 完整写法：[起始:结束:步进]
  print(s[::2])
  # 逆序
  print(s[::-1])

   

• 格式化操作

  name = '二狗'
  like = '大花'
  age = 18
  # 格式化
  # %s：字符串
  # %d：整数
  # %f：浮点数
  # %c：单个字符
  print('俺叫%s，暗恋%s，今年%d岁' % (name, like, age))
  ​
  # python中推荐使用以下的方式
  print('俺叫{}，暗恋{}，今年{}岁'.format(name, like, age))
  # 可以通过指定序号控制顺序
  print('俺叫{1}，暗恋{0}，今年{2}岁'.format(name, like, age))
  # 也可以通过名字控制顺序
  print('俺叫{l}，暗恋{n}，今年{a}岁'.format(n=name, l=like, a=age))
  ​
  # 填充与对齐
  s = 'hello'
  # < 左对齐
  print('{:<8}'.format(s) + 'AAA')
  # > 右对齐
  print('{:>8}'.format(s))
  # 填充0
  print('{:0>8}'.format(s))
  # 填充A
  print('{:A>8}'.format(s))
  ​
  # 以指定的进制显示:b二进制，d十进制，o八进制，x十六进制
  print('0b{:b}'.format(123))
  print('{:d}'.format(123))
  print('0o{:o}'.format(123))
  print('0x{:x}'.format(123))

   

系统函数

• print

• input

• type

• len

练习

• 当前的内容敲3遍

• 根据字符串操作测试列表、元素、集合、字典等相关操作

• 各种运算及分支结构