python-基础数据类型

基础数据类型

• 数字

  • 整数（int）：整数的具体长度取决于内存的大小

    • Python2

      • 长整数

      • 短整数

    • python3

      • 只有整数

  • 浮点数（float）：具有小数点的数

    • python2,3都会做精度处理

  • 布尔（bool）：真，假

    • True：非空非零为真

    • False：0或空为假

    • None：空（是假的）

      注意：python区分大小写

  • 复数（complex）

• 字符串（str）：一个连续有顺序的数据类型（序列）(不可变数据)

  • 变量在定义的时候一定要明确数据类型

  • 标点符号来确定数据类型

  • 索引：按照数据的位置来访问到某一个具体的值

    • 从左到右：0开始

    • 从右到左：-1开始

  • 切片：一次不仅仅取一个值

    • a = 'abcdef'
      a[start:stop:step]
      start:起点
      stop:终点（左闭右开）
      step:步长
          当步长为负时，值的索引不变，颠倒的是值但是索引不变；步长为负，起点比终点大。
          取值是从左到右
          a = ''
          a是真的，还是假的？
          a是假的
        >>> a = list(range(10))
      >>> a
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
      >>> a[1:] #从1开始（左闭右开所以1位置上的值可以取到），得到一个新列表
      [1, 2, 3, 4, 5, 6, 7, 8, 9]
      >>> a[2:]# #从2开始（左闭右开所以2位置上的值可以取到），得到一个新列表
      [2, 3, 4, 5, 6, 7, 8, 9]
      >>> a[:2] #从2结束（左闭右开所以2位置上的值不能取到），得到一个新列表
      [0, 1]
      >>> a[:3] #从3结束（左闭右开所以3位置上的值不可以取到），得到一个新列表
      [0, 1, 2]
      >>> a[::2]#步长为2，间隔为2，得到新列表
      [0, 2, 4, 6, 8]
      >>> a[2:-3]#从2位置开始，-3位置结束
      [2, 3, 4, 5, 6]
      >>> a[-3:-6:-1]#从-3位置开始，-6位置结束；位置颠倒但是下标不变
      [7, 6, 5]
      >>> a[::-1]#步长为负数，倒序，-1间隔为1
      [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
      >>> a[::-2]#步长为负数，先倒序，在取值，-1间隔为2
      [9, 7, 5, 3, 1]
      >>> a[2::-2] #从2位置取，有间隔为2，得到新列表
      [2, 0]
      >>> a[:1:-2]
      [9, 7, 5, 3]#从1结束，左闭右开，取不到1位置上的值，间隔为2

  • 字符串中的数据是没有意义的

• 列表 ：（可变数据，功能性高）

  • 也是个序列，而且支持任意数据类型

  • 语法 a= []

• 元组：（不可变数据）

  • 语法 a =()

  • 创建单个元组时，一定在后面加逗号

  • 不可变数据类型

    • 元组不可变

  • 元组中的列表可变吗？

    ​ 不可以，但是元组列表中的数据是可以变

• 字典：

  • 语法：{key:value} （key值是绝对唯一的，且只有不可变数据才能作为key值，空字符串，空元组也可以做key值）

  • 创建字典：

    • 方法一：a = {1:'a'}

    • 方法二：

      >>> mydict = dict(([1,2],[3,4]))
      >>> mydict
      {1: 2, 3: 4}

    • 方法三：内建函数dict.fromkeys()

      >>> dict.fromkeys(['a','b','c'],1)
      {'a': 1, 'b': 1, 'c': 1}
      字典来自于hash表构成，hash的检索特别快，hash之后，key值对应的hash值会指向一个具体value地址，也就是为什么我们通过key值访问value很快。
      hash算法处理后的数据，之后的值绝对是唯一的，所以key值是一个不能变的；
      字典不支持索引，切片;但是字典是可变数据类型
      字典也算的上是一个无序的数据类型，在python3.6字典有序
      key:
        key值唯一
        不可变的数据（绝对不包含可变的）才可以做key值
        key值必须是一个不可变的数据对象：数字，字符串，元组
      value:
        value可以重复
        value可以是任意数据类型

  • 访问字典

    • 方法一：a[key] -> value

    • 方法二：内建函数dict.keys()

      ​ dict.values()

      ​ dict.items()

  • 更新字典

    • 如果key值存在，直接dict[key]=value

    • 如果key不存在，添加新的键值对

  • 删除字典

    • del

    • dict.pop()

    • dict.clear()清空

判断字典是否在字典中（in | not in）

• 集合（set）

  • 语法：a = set{'字符串'}

  • 集合中每一个数据都会经过hash，集合会去重；也可以用（in | not in）判断；相当于没有value的字典

  • 可变

  • 对集合更新

    • set.update()

    • set.add()

  • 删除集合

    • set.pop()

    • set.remove()

变量本质

python中没有真正意义上的不可变数据

• 所谓的不可变，都是不能变他的内部

python中不需要定义数据类型

可以为多个变量赋值

例子：a,b = 1,1

不支持自增自减

变量命名格式：

• 字母，数字，下划线（py3支撑中文做变量名）

• 数字不可以打头

• 尽量不要用数字作为一个脚本名

  • 自己给自己写一些接口（功能性函数）

变量引用计数 ：共享

• 内存：

  • 存储变量需要内存

  • 实际数据需要内存

  • 指向关系，指针

• 独立：彼此互不影响（C，Java的变量创建就是这样）

  • 缺点：浪费内存，容易造成内存碎片

• 共享：节约内存

  • python本身就在使用一些基础变量

• id（）查看当前变量的内存地址

• 释放变量

  • 记录变量的使用个数，引用计数

• del，删除一个变量名，并是数据的引用数字减1

• 引用计数的获取方式：

  import sys
  sys.getrefcount(a)

• del语句只是删除了变量名

  • 本质没有影响实际数据

  • 当引用计数为0时，python才会回收数据

    • 回收有延迟性

• 引用计数深究

  a = [1,2,3,4,5]
  b =[1,2,3,4,5]
  >>> a
  [1, 2, 3, 4, 5]
  >>> b
  [1, 2, 3, 4, 5]
  >>> id(a)
  139854087573704
  >>> id(b)
  139854087575944
  >>> id(b[0])
  9082912
  >>> id(a[0])
  9082912

  • 可变数据在单独赋值时，不会使用引用计数

  a = [1,2,3,4,5]
  >>> b = a
  >>> id(a)
  139854087573704
  >>> id(b)
  139854087573704
  >>> a[0] ='b'
  >>> a
  ['b', 2, 3, 4, 5]
  >>> b
  ['b', 2, 3, 4, 5]

  • 直接使用变量赋值时，会使用引用计数

  • 一旦可变数据使用引用计数，你变我也变

• 不可变数据在使用引用计数时的修改

  • 一个修改，一个不变（不可变修改的不是内部的，而是移动了位置）

深浅拷贝

• 切片拷贝

• 深浅拷贝使用的是可变数据类型；

  >>> import copy
  >>> b = copy.copy(a)
  >>> b
  ['b', 2, 3, 4, 5]
  >>> a
  ['b', 2, 3, 4, 5]
  >>> a[0] = 'r'
  >>> a
  ['r', 2, 3, 4, 5]
  >>> b
  ['b', 2, 3, 4, 5]

  copy.copy（）函数只是一层的copy；而copy.deepcopy()是深层拷贝

  > c = copy.deepcopy(a)
  b = copy.copy(a)
  >>> c
  [1, 2, [4, 5, 6, (3, 5, 6)], 677, 8, (1, [7, 8, 9], 2, 3)]
  >>> a[2]
  [4, 5, 6, (3, 5, 6)]
  >>> a[2][2] = 'a'
  >>> a
  [1, 2, [4, 5, 'a', (3, 5, 6)], 677, 8, (1, [7, 8, 9], 2, 3)]
  >>> b
  [1, 2, [4, 5, 'a', (3, 5, 6)], 677, 8, (1, [7, 8, 9], 2, 3)]
  >>> c
  [1, 2, [4, 5, 6, (3, 5, 6)], 677, 8, (1, [7, 8, 9], 2, 3)]

• 当可变数据类型使用了引用计数时，你变我也变，而深浅拷贝却不会变

运算表达式

• 操作符：（+，-，*，/，//,%,**）

  • 加减乘除和取余是标准操作符，但是python有两种除法'/'和'//'；'/'用作传统除法，而'//'用作浮点数除法（对结果进行四舍五入）；'**'是乘方操作

• 同类型数据（字符串，列表）可以支持加法（拼接）和乘法（重复）

  • 创建一个新的数据类型，原有的数据不变

• //直接将小数点后的精度舍去

条件分支

• if 条件
      执行
   elif 条件
      执行
    else 不符合上面的条件
      执行

判断表达式

• == , >= ,<= ,!=,<,>

  • python中的不等于：!= 和 <>

逻辑表达式

• not

• and

• or

• is

• is not (is 不仅仅判断值，还判断内存地址；判断的是一个对象)

while

• while 条件：
      执行
  else：
      结束后正常执行

for

• for var in 序列：
      执行
  else：
      正常结束执行

干预循环

break：直接结束循环

continue：结束本次循环，执行下一次循