Python学习笔记

#人生苦短，我用python#

###type（类型）
  - 用来检查值的类型，该函数会将检查的结果作为返回值返回
  - 通过type()函数查看当前对象类型
  - python是强类型语言，对象一旦创建则不能修改
### id（标识）
  - 用来标识对象的唯一性，每个对象有唯一的id
  - 通过id()函数来查看对象的id
  - 一个对象的id值在CPython解释器里就代表它在内存中的地址
  - 对象一旦创建id不改变
### value（值）
  - 值就是对象中存储的具体数据
  - 有些对象值可以改变
### 类型转换
  - 类型转换不是改变对象本身的类型，而是根据当前对象的值创建一个新的函数
### 算数运算符（略）
  - //：整除（只返回结果的整数位）
  - **：幂（幂运算）
### 关系运算符（略）
  - 在py中可以对两个字符串进行比较运算（类似于C中的strcmp？？）
  - 实际上比较两字符串的Unicode编码，逐位比较（与strcmp类似）
    > 注意:如果不希望比较两字符串的Unicode编码，则需要转换为数字再比较
  - is：比较两个对象是否同一个对象，比较的是id
  - is not：比较两对象是否不是同一对象，比较id
### 逻辑运算符
  - and：逻辑与（且）
  - or：逻辑或
  - not：逻辑非
    > python中也存在逻辑短路
### 列表（list）
  - 类似于数组
  - 列表名 = [元素,元素,----]
  - len()函数可获取列表中元素的个数
  - min()函数获取列表中最小值
  - max()函数获取列表中最大值
  - 如果索引是负数，则从后向前获取元素，-1表示倒数第一个，以此类推
  - 切片
     - 通过切片来获取指定的元素
     - 语法：列表[起始:结束]
      1. 通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素
      2. 不会影响原来列表
      3. 省略结束位置，则截取到最后
      4. 省略起始位置，则会从第一个元素开始截取
      5. 都省略则相当于原列表
     - 语法：列表[起始:结束:步长]
      1. 步长默认为1，指每次获取元素的间隔
  - 通用操作
     - +号可以将两个列表拼接为一个列表
     - *号可以将列表重复指定次数
     - in 用来检查指定元素是否存在于列表中
     - not in 用来检查指定元素是否不再列表中
  - 方法
     - e.g.:xxx.index()
     - 方法实际上是和对象关系紧密的函数
     - xxx.index() 获取指定元素在列表中的索引
     - xxx.count() 获取指定元素在列表中出现的次数
  - 序列（sequence）
    - 序列是Python中最基本的一种数据结构
    - 序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引），并且序列中的数据会按照添加的顺序来分配索引
    - 序列的分类：
       - 可变序列（序列中的元素可以改变）：
          > 列表（list）
       - 不可变序列（序列中的元素不能改变）：
          > 字符串（str）    
          > 元组（tuple）
  - 修改列表（不可变序列无法通过索引修改）
     - 类似数组
     - del 列表名[2] 删除索引为2的元素
     - 通过切片也可修改列表
     - 使用新元素替换旧元素
        - 列表[0:2]=['xxx','xxx']
        - 也可 列表[0:2]=['xxx','xxx'，'xxx']
     - 向列表首位插入新元素
        - 列表[0:0]=['xxx']
     - 当设置了步长时，序列中新元素个数必须和切片中匹配的元素个数一致
     - 通过切片可删除元素
     - 可通过list()函数将不可变序列转换为列表再行修改
  - 列表的方法
     - 列表.append() 向列表的最后添加一个元素
     - 列表.insert(a,b) 向列表的指定位置插入一个元素
        - 参数 
          > a:要插入的位置  b:要插入的元素
     - 列表.extend() 实用新序列来拓展当前序列
        - 需要一个序列作为参数，将该序列中的元素添加到当前列表中
     - 列表.clear() 清空序列
     - 列表.pop(2) 删除索引为2的元素，并返回被删除的元素
     - 列表.pop() 留空的话默认删除最后一个元素
     - 列表.remove() 删除指定值的元素，若相同值元素有多个，只会删除第一个
     - 列表.reverse() 反转列表
     - 列表.sort() 用来对列表中元素进行排序，默认**升序**排列
        - 若需要降序排列
        - 则使用 列表.sort(reverse=Ture)
  - for循环
     - 定义stu为一列表,列表中有各种元素
     - 则`for s in stu `
           ` print(s)`
     - 则变量s每次循环都改变一次，取值为一个元素
     - 遍历整个列表后退出循环
  - range() 可用来生成一个自然数的序列
     - 如`r = range(5)`生成一个这样的序列[0,1,2,3,4]
     - 该函数需要三个参数
        1. 起始位置（可省略，默认为0）
        2. 结束位置
        3. 步长（可省略，默认为1）
    > range()可以创建一个执行指定次数的for循环（配合for循环使用）
    >> 如 `for i in range(30)` i 会遍历0到30
### 元组（tuple）
  - 元组是一个不可变的序列
  - 操作方法基本与列表一致
  - 操作元组时，将元组当做不可变的列表就行
  - 一般希望数据不改变时，就使用元组
  - 元组名 = (元素,元素,----)
  - 当元组不为空元组时，括号可省略
  - 如果元组只有一个值，里边必须要有一个 , ，不然会识别为整型
  - 元组的解包（解构）
    - 就是指将元组中每一个元素都赋值给一个变量
    - 如`tuple = 1,2,3,4`
  - `a,b,c,d = tuple`
    > 交换 a 与 b 的值，利用元组的解包（解构）
    `a , b = b , a`
  - 在对元组进行解包时，变量的数量必须和元组中的元素的数量一致
  - 也可以在变量前加一个*，这样变量将会获取元组中所有剩余的元素
  - 加*的变量构成成一个列表
  - 不能同时出现两个或两个以上的*变量
    > 列表、字符串也可以解包
### 字典（dict）
  - 字典属于一种新的数据结构，称为映射（mapping）
  - 字典的作用和列表类似，都是用来存储对象的容器
  - 列表存储数据的性能很好，但是查询数据的性能的很差
  - 在字典中每一个元素都有一个唯一的名字，通过这个唯一的名字可以快速的查找到指定的元素
  - 在查询元素时，字典的效率是非常快的
  - 在字典中可以保存多个对象，每个对象都会有一个唯一的名字，称为键（key），这个对象称为值（value），所以字典也称为键值对（key-value）结构
  - 每个字典中都可以有多个键值对，而每一个键值对我们称其为一项（item）
  - 使用｛｝来创建字典 如`d = {}`
  - 语法：
    - ｛key:value,key:value,----｝
    - 字典的值可以是任意对象
    - 字典的键可以是任意的不可变对象
    - 字典的键不能重复，若出现重复的，后边的替换前边的
    - 需要根据键来获取值
      - 如`print(d['name'],d['age'])`
  - 或者使用dict()函数创建字典
    - 如`d = dict(name='xxx',age=18,gender='男')`
  - 也可将一个包含有双值子序列的序列转换为字典
    - 双值序列：序列中只有两个值，[1,2] ('a',3) 'ab'
    - 子序列：序列中的元素也是序列
      - 如`[(1,2),(3,5)]`
  - len()函数可获取字典中键值对个数
  - in 可检查字典中是否包含指定的键（not in）
  - 获取字典中的值：
    - `d['age']` （此方法键不存在抛出异常）
    - 通过 键名.get('age') 来获取（此方法若键不存在返回None）
      - 也可指定一个默认值作为第二个参数，获取不到值时将返回此默认值，如`d.get('name','默认值')`
  - 修改字典
    - d[key] = value
      - 如果key存在则覆盖，不存在则添加
    - d.setdefault('name','xxx')
      - 如果键name存在，则返回name的值，若没有name这个键，则添加一个键值对，键为name，值为xxx
    - d1.update(d2)
      - 将d2中的键值对添加到d1中，如果有重复的key，则d2中的会替换掉d1中重复的
    - del d('a') 可以删除字典中键为a的键值对
    - d.popitem() 随机删除一个键值对，一般都会删除最后一个键值对，返回一个元组，元组中有两个元素，key和value
    - d.pop('a') 删除指定的键值对，返回被删除的值
      - 若删除不存在的key，抛出异常
      - 改为d.pop('a','默认值') 则返回默认值
    - d.clear() 清空字典
    - d.copy() 用于浅复制字典，复制以后的对象和原对象独立，修改一个不会改变另一个
      - 如`d2 = d1.copy()`
      - 注意：浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会改变
  - 遍历字典
    - d.keys() 该方法会返回一个序列，序列中保存有字典的所有的键
      - 可以通过遍历keys()获取所有的key
        - 如`for k in d.keys():`
    - d.values() 返回一个序列包含所有的值
    - d.items() 返回字典中所有的项
      - 返回一个序列，包含有双值子序列
      - 双值分别是key和value
### 集合
  - 集合和列表非常相似
  - 不同点：
    1. 集合中只能存储不可变对象
    2. 集合中存储的对象是无序（不是按照元素的插入顺序保存）
    3. 集合中不能出现重复的元素
  - 使用{}创建集合
    - s = {1,2,3,4}
  - 使用set()函数创建集合
    - s = set() 创建了一个空集合
    - 可以通过set()将序列和字典转换为集合
        > 转换为字典时，只会包含字典中的键(key)
  - s.pop() 随机删除并返回一个集合中的元素
  - s.remove() 删除集合中的指定元素
  - 其余函数类似字典
  - 集合的运算
    - 在对集合做运算时，不会影响原来的集合，而是返回一个运算结果
    - 交集运算（&）
    - 并集运算（|）
    - 差集运算（-）
    - 异或运算（^）获取只在一个集合中出现的元素
    - <= (>=)检查一个集合是否是另一个集合的子集
    - < (>)检查一个集合是否是另一个集合的真子集
### 函数
  - 关键字参数，可以不按照参数定义的顺序去传递，而直接根据参数名传递参数
    - fun(b=1,c=2,a=3)
  - 不定长参数
    - 在定义函数时，可以在形参前加一个*，这样这个形参将会获取到所有的实参，并保存在一个元组中
    - 带*参数只能有一个
    - 带*参数不是必须写在最后，但其后的所有参数必须以关键字参数的形式传参
    - 带*参数只能接受位置参数，而不能接受关键字参数
    - **形参可以接受其他的关键字参数，并保存在一个字典中
    - **形参只能有一个，并且必须写在所有参数最后
    - 传递实参时，可以在序列的参数前添加*号，这样会自动将序列中的元素作为参数对应传递，要求序列中元素的个数必须和形参个数一致
    - 通过**来对一个字典进行解包，类似上条
  - help() 是Python中的内置函数
    - 可以查询py中的函数用法，包括用户自定义的函数
  - locals() 用来获取当前作用域的命名空间，返回值是字典
  - 高阶函数
    - 高阶函数至少要符合以下两个特点中的一个
      1. 接收一个或多个函数作为参数
      2. 将函数作为返回值返回
  - filter() 可以从序列中过滤出符合条件的元素，保存到一个新的序列中
    - 参数：
      1. 函数，根据该函数来过滤序列（可迭代的结构）
      2. 需要过滤的序列（可迭代的结构）
      3. 返回值：过滤后的新序列（可迭代的结构）
  - 匿名函数 lambda 函数表达式
    - lambda函数表达式专门用来创建一些简单的函数，是函数创建的又一种方式
    - 语法：`lambda a,b : a+b`即lambda 参数列表 ： 返回值
  - map() 可以对可迭代对象中所有元素做指定的操作，然后将其添加到一个新的对象中返回