python笔记(一)

·查看当前版本 conda -V
·查看当前环境信息 conda env list  或者 conda info -e
·查看当前环境已经安装的包 conda list
·为 conda 添加国内镜像源 conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/an aconda/pkgs/main/
·查看当前conda配置状态 conda config --show channels 
·创建 Python 虚拟环境 conda create -n 自定义环境名称 python=x.x(python版本号)
       解释：创建 Python 版本为 x.x，名字为 your_env_name 的虚拟环境； your_env_name 文件可以在 Anaconda 安装目录 envs 文件下找到
·激活或者切换虚拟环境 conda activate 环境名称
·搜索指定的 package 都有哪些版本 conda search package_name
·在当前环境下安装指定 package conda install package_name=x.x
       解释：在当前环境安装指定版本的包，不指定版本默认安装最新的
·在指定环境中安装 package conda install -n your_env_name package_name=x.x
·恢复默认源 conda config --remove-key channels
·退回到 base 环境 conda deactivate
·删除当前环境中的某个包 conda remove package_name
·删除指定环境中的某个包 conda remove -n your_env_name package_name
·删除虚拟环境 conda remove -n your_env_name --all

进制转换

一般进制分为十进制、二进制、八进制、十六进制(10-15分别用a-e表示)

十进制转二进制将45转换为二进制位101101，一般为八个字节前面用0补齐 00101101

十进制转八进制

十进制转十六进制

二进制转八进制/十六进制

第一种方法是将二进制转化成十进制，二进制数字从右往左下表从0开始计算2的0次幂(101101= 2`0+0+2`2+2`3+0+2`5 = 45) ，再将十进制转化为八进制比较麻烦

可以直接八进制3位来看对应相应的位数，十六进制是四位比如（转八进制）00 101 101 = 55 (转十六进制) 0010 1101 = 2d （对应位数也是将二进制数字从右往左 0开始计算2的n次幂进行相加，为0时跳过）

八进制/十六进制转十进制也是将八进制的数字从右往左下标从0开始，计算8的n次幂进行相加

Python 3 中有六个标准的数据类型：

数字（Number）字符串（String）列表（List）元组（Tuple）字典（Dictionary）集合（Set）

垃圾自动回收机制

python关键字查询

或者直接用

help("keywords")

内置函数查询

十六进制前缀 0x 八进制0o 二进制是0b

序列包含：字符串、元组、列表

索引操作&切片

"""
  索引操作 正向索引从0开始，结束索引为 len-1，反向索引从-1开始，结束为 -len

  索引操作超出范围时会报错,切片操作超出范围不会报错

  len 获取的长度（除了数字不可求长度外，其他的数据类型均可以）

  切片 字符串[起始索引(start) : 结束索引(end) : 步长(step)] 左闭右开,结束索引是开区间，不包含，如果需要最后一位的话，需要往后多写一位一位

  当step没有指定时，默认为1

  当ster为正数，那么

  ----- end结束索引没有指定时，默认为长度,当结束索引超出范围时不会报错

  ----- start起始没有指定时，默认为0或者 -len

  当step为负数，那么

  ----- end结束索引没有指定时，默认为-len -1

  ----- start起始没有指定时，默认为-1，或者len-1

  step步长为正数,从左往右取，step步长为负数，从右往左

"""

使用b、d、o、x 分别输出二进制、十进制、八进制、十六进制数字

索引会降维，切片不会

字符串对象方法

"""
  注：[]为可选参数
  替换 string.replace(old, new, [count]) 
        old：旧字符串 new：新字符串 count：要替换的最大次数，默认为-1，替换所有能替换的
  移除 string.strip(chars) (剥掉外表皮，不去掏空内部，从左往右&从右往左遇到不能移除的即结束，输出剩余字符串)
        chars 为多个字符,会考虑chars的所有组合
  居中 string.center(宽度, [fillchar]) 将字符串置于中间，宽度大于原字符串长度时，左右填充(原字符串长度为奇数，左边更少，长度为偶数，左边更多)，宽度小于原字符串长度时输出原字符串
        fillchar 填充字符串，必须是单个字符，默认为空格
   左对齐 str.ljust(宽度, [填充字符串]) 
   右对齐 str.rjust(宽度, [填充字符串]) 
   分割  str.partition(sep) sep分隔符，字符/字符串，从左往右找分隔符，
                返回为元组 (分割符之前部分，分隔符本身，分隔符之后部分)
        str.rpartition(sep) 寻找方向为从右往左找分隔符，但字符串顺序不变
  判断开始 str.startswith(prefix,[start, end]) 判断字符串是否以特定字符串开始
            prefix：匹配的前缀，可以是字符，字符串或者它们组成的元组（元组中只要一个元素满足即可
            start/end 指定区间，以 下标 为准
            返回值为 True/False
  判断结束 string,endswith(prefix,[start, end])
  判断构成成分(均返回bool)
      str.isalnum 判断均为字母&文字&数字
      str.isalpha 判断均为字母或文字
      str.isdigit 判断均为数字
      str.isspace 判断均为空白符（空格/换行/制表符）
  分割 str.split(sep=None, maxsplit=-1)
            sep：用于分割字符串的分隔符, 默认为所有的空白符（空格、换行、制表符等）,并丢弃结果中的空字符串
            maxsplit：最大分隔次数，默认为-1即所有
            返回值为字符串list, 不保留分割符号
      str.rsplit(sep=None, maxsplit=-1) 分割 从右往左,取片段还是从左往右取
  拼接 str.join(iterable) 
            iterable：可迭代对象,包括 string、list、tuple、dict、set等等,传可迭代对象一般是需要对元素进行操作
            将可迭代对象中的元素(元素必须是字符串类型)以指定的字符串连接，返回新的字符串
  计数  str.count(sub, [start, end]) 计数子字符串，不重叠
            sub：指定的子字符串
            start/end 可选，区间
  查找 
        str.find(sub,[start, end]) 返回从左开始第一次找到指定子字符串时的索引，找不到就返回-1
        str.rfind(sub,[start, end]) 返回从右开始第一次找到指定子字符串时的索引，找不到就返回 -1
        str.index(sub,[start, end]) 类似于find()，唯一不同在于，找不到就会报错，其他都一样
        str.rindex(sub,[start, end]) 类似于rfind()，唯一不同在于，找不到就会报错，其他都一样
        注：无论从左往右还是从右往左，返回的索引为原字符串的索引，查找时区分大小写, end不包含
  修改大小写
        str.capitalize() 将字符串的首字母变成大写，其他字母变小写，并返回
        str.title() 将字符串中所有单词的首字母变成大写，其他字母变小写，并返回
        str.upper() 将字符串中所有字符变成大写，并返回
        str.lower() 将字符串中所有字符变成小写，并返回
        str.swapcase() 将字符串中所有大写字符变成小写，小写变成大写，并返回
"""

列表(List)

"""
列表修改 
    可用两种方法
    1 lst[index]='a'
    2 lst[start:end:step] = 可迭代对象
    可迭代对象中的元素可多于 end-start的数量，当step>1时 元素数量需要相等
    当可迭代对象为字符串时，会将字符串分割成字符进行赋值


list对象方法
    注：list在进行修改时，会在原地进行操作，避免了重新创建，浪费空间,无返回值
     将可迭代对象转换为list list([iterable]) 参数可选
            如果为字符串时，会将字符串分割为字符进行赋值，不可用str返回至 字符串，可以用 ''.join(list)
    追加  list.append(x) 在末尾追加元素,原列表操作.无返回值
                相当于 a[len(a):] = x
    批量添加  list.extend(iterable)
                相当于 a[len(a):] = [x1,x2,x3]
    插入  list.insert(i,x) 只能插入单个数据
            i： 要插入的索引 x：要插入的数据
    排序  list.sort([key], reverse) 原地操作，无返回值
            key:指定为函数名称，排序之前各个元素应用该函数后在进行排序，可为自定义函数
            reverse: 排序方法默认为false-升序,true为降序
            # 序列根据大小进行排序，如果为字符串 根据第一个字符大小进行排序，如果有字符时看ascall码
            # 数字和字符串不能比较大小，比较列表时根据位置进行比较
         sorted(iterable,[key],reverse=false) 对可迭代对象进行排序（不对原数据进行操作），以列表形式返回
         sort 和 sorted 的区别：
            list.sort 是只针对列表的排序，对原数据进行操作，无返回值，是列表的对象方法
            sorted 可以对所有可迭代的对象进行排序，不对原数据操作，有返回值，是内置函数 
    反向  list.reverse() 将列表逆向进行返回,无排序，原地操作无返回值
         reversed(seq)  对给定序列返回一个反向迭代器
         reverse 和 reversed 区别：
            list.reverse是只针对列表的，对原数据进行操作，无返回值，是列表的对象方法
            reversed 是针对序列的，不对原数据操作，返回一个反向迭代器，是内置函数
    计数 list.count(x) 计算x在列表中出现的次数,没找到返回0
    查找 list.index(x,[start,end]) end不包含
            返回从列表中第一次找到指定值 x 的位置索引，找不到则抛出 ValueError 异常
            注意：返回的索引是相对于整个序列开始计算的，而不是 [start:stop] 的子序列
    删除  list.pop([i])(解除引用)
                i：要删除的元素下标，可选，不传时，删除最后一个元素
                注意：pop有返回值，返回删除的元素，没元素进行删除时会报错
          list.remove(x) (解除引用)
                x:元素，删除查找到的第一个匹配到的元素（修改原列表，无返回值）
                如果没有该元素，抛出ValueError
    复制  list.copy 返回列表的一个浅拷贝 等同于 a[:]
    清空  list.clear 移除列表中的所有元素 等同于 del a[:] 返回[]
    del  (解除引用)在删除变量时，不直接删除数据，而是解除变量对数据的引用关系，当数据的引用计数为0时，数据会变成了一个可回收的对象，内存会被不定期回收

"""

迭代器和可迭代对象的区别：

1、迭代器一定是可迭代对象，反之则不然
2、迭代器每个元素只能用一次（输出为地址可以用list转列表，但迭代器只能用一次,再次使用会返回空列表）

封包

当多个对象同时赋值给同一个变量时，此时会自动将多个对象打包为一个元组

元组

定义元组时，只有一个元素逗号不能省略

元组和列表的最大区别：元组不可变，列表可变元组不可变，

元素不可增删改(元素中有list时，可以对list的元素进行增删改)

浅拷贝对元组没有意义(未讲)

元组对象方法

tuple([iterable]) 不传返回空元组

字典

字典是可变的，3.7之前是不连续的不是序列，当前版本(3.7版本之后)是序列

键值对 {键:值} 字典的键不能包含可变的数据类型，值没有限制

字典属于可迭代对象,字典如果作为可迭代对象，只有键参与迭代

字典的键会自动去重，(仅保留第一个)，值取最后一个重复项(值会做更新)

dic(可迭代对象) dic([(键，值),(键2，值2)])

zip 返回迭代器，可以用list转列表(两两成对，各成一组)

"""
不定长参数
    - *arg 接收[0,+∞]个位置参数，贪婪，打包成一个元组，没有实参输出空元组
    - **kwargs 接收[0,+∞]个关键字参数，贪婪，打包成一个字典，没有实参输出空字典
    
    对象方法
    dict.keys 返回字典中的键
        返回字典键组成的一个新视图(dict_keys),字典改变时，对应的视图也会改变
    dict.values 返回字典中所有的值 
        dict_values
    dict.items 返回所有的键和值
        dict_items dict_keys、dict_values视图类均为可迭代对象,均可用list转为列表
        当原数据发生改变时，视图也会发生变化，视图的内存地址不变
        
    dict.get(key,defaut=None]) 返回指定的键 key 对应的值
        key:键, 如果 key 不在字典中，则返回 default
        default:指定键不存在返回该值，默认none
    dict.update([other]) 原地操作 无返回值
        
    dict.pop(key,[default]) 指定键删除键值对
          移除指定键，并返回对应的值，如果key不在字典中，返回default，未指定default会返回报错
    dict.popitem 移除最后一个键值对，返回他们构成的元组
    dict.setdefault(key,[default])  返回指定的键 key 对应的值
        如果key对应的键不存在，加入值为 default 的键 key，并返回 default，default 默认为 None
    dict.copy() 返回原字典的浅拷贝
    dict.clear() 移除字符串中所有元素，无返回值
"""

集合

集合是无序的

集合是可变的，不是序列

集合中不能存在可变的数据类型(不能嵌套，可以嵌套冻结集合)

集合中的元素会自动去重

set() 设置空集合

frozenset() 设置空的冻结集合冻结集合无序不可变

"""
    关系
        print(a <= b)  # 真子集 父子集 false
        print(a <= b)  # 真子集 父子集 false
        print(b <= a)  # 真子集 父子集 true
        print(a & b)  # 交集 {1, 2}
        print(a | b)  # 并集 {1, 2, 3, 4, 5, 6, 7}
        print(a - b)  # 差集 {3, 4, 5, 6, 7}
        print(b - a)  # 差集 set()
        print(a ^ b)  # 对称差集 {3, 4, 5, 6, 7}
        
    对象方法
        set和frozenset都可用
          isdisjoint(other) 判断集合中是否与other共有元素，没有则返回True
              other:可迭代对象  set & other
          issubset(other) 判断集合1是否是other的子集  如果集合中的每个元素都在 other 之中，则返回 True
              等同于 set <= other
          issuperset() 如果 other 中的每个元素都在集合之中，则返回 True
              set >= other
          union(*other) 并集  set | other | ... 要求参数为集合
                other 可传多个可迭代对象，等同于 set | other
                如果other中存在字典只有键参与迭代
          intersection(*other) 求交集  set & other & ... 要求参数为集合 
          difference(*other) 求差集 等同于set - other
          symmetric_difference(other) 对称差 只能传一个可迭代对象
          
          
        仅set可用
            set.update(*others)
                添加来自other的所有元素,相当于原地添加求并集
            set.intersection_update(*other)
                更新操作，只保留其中在所有 others 中也存在的元素
            set.add(elem) 添加
                将元素elem添加到集合中，元素已存在则无影响
                elem不能存在可变数据类型
            set.remove(elem) 移除 元素不存在报错
            set.discard(elem) 移除  元素不存在无影响
            set.pop() 集合中随机删除第一个元素(集合中的元素无序，每次删除第一个)
                集合为空集合会报错
            set.clear() 清空集合   
"""

浅拷贝和深拷贝

id(obj) 获取对象的内存空间地址
[-5,256]事先存储好并不会被释放（小整数对象池）

对于浅层拷贝 (copy.copy)

对于浅层拷贝不需要考虑其中的元素
不会发生拷贝的数据类型有：数字num、字符串str、元组tuple
会发生拷贝的数据类型有：列表list、字典dict、集合set

对于深层拷贝 (copy.deepcopy)

        对于深层拷贝，除了考虑数据本身还需要考虑其中的元素
        不会发生拷贝的数据类型有：数字num、字符串str、元组tuple(不存在可变数据类型)
        会发生拷贝的数据类型有：列表list、字典dict、集合set、元组tuple(存在可变数据类型)

小结：

1、对于浅层拷贝而言，如果拷贝的对象本身是可变的数据类型，则数据本身发生拷贝，其中的元素仍未引用关系
2、对于浅层拷贝而言，如果拷贝的对象本身是不可变的数据类型，则不会发生拷贝，仍为引用关系

        1、对于深层拷贝而言，如果拷贝的对象本身是可变的数据类型，则会发生拷贝
        2、对于深层拷贝而言，如果拷贝的对象本身是不可变的数据类型但其中存在可变的数据，则仍会发生拷贝
        3、对于深层拷贝而言，如果拷贝的对象本身是不可变的数据类型，并且其中不存在任何的可变的数据，则不会发生拷贝
        4、如果发生拷贝，对于其中的每个成员是否发生拷贝，只需要根据前三点判定即可

运算符

           算数运算符 +、-、*、/、%(取模)、**(幂运算)、//(整除，相当于/完之后向下取整) 、% 如果a!=0,那么 a%b + (-a) %b = b
序列(字符串、列表、元组) 可以用+、*n(n位数字表示重复n次)进行拼接, 字典不可以

增强赋值 a += b (a的源地址数据进行改变)
普通赋值 a = a + b # 复制一份新数据进行拼接
增强赋值比普通赋值效率更高(增强赋值在数据为字符串、元组类型时，数据本身不会发生变化，操作时和普通赋值一样会复制)

海象运算符: 允许在表达式中进行赋值, =、:= 优先级最低

序列赋值

* 等号右边必须是可迭代对象(不可是数字)
a,b,c = '可迭代对象' abc会是每个可迭代对象的参数
等号左边变量参数必须得和右边的可迭代对象数量相等
可以用序列赋值进行数据交换，同时进行
a, b, c, d = 1, 2, 3, 4 # 同时
普通 a = 1 b = 2 # 有顺序

多目标赋值：一个对象同时赋值给多个变量
a = b = c = d = [1, 2, 3, 4]
多个变量指向同一个地址，当对象为可变类型并且发生变化时，其他变量也进行变化

逻辑运算符

and 布尔与运算,左边进行bool判定，为false时返回左边，否则返回右边
or 布尔或运算,左边进行bool判定，为true时返回左边，否则返回右边
not 布尔非运算,后边进行bool判定，为true时返回false，否则返回true
同时出现优先级 not>and>or
逻辑运算符的短路原则:如果前面的部分已经计算出整个表达式的结果，则后面的部分不再计算
all(iterable) 全为true时返回true all([]) => true
any(iterable) 有一个元素为true时，返回true any([]) => false

成员运算符

in 在其中
not in 不在其中
需要传可迭代对象，返回bool值
print(1 in ('hello', True)) => True
print('he' in 'hello') => True
print('helo' in 'hello') => false

身份运算符

is 判断两个标识符是不是引用自一个对象，类似判断 id(a) == id(b)
is not 判断两个标识符是不是引用自不同对象，类似判断 id(a) != id(b)
is 和 ==的区别 ==判断大小, is判断内存地址

位运算符

         binx(x) 十转二进制 =>返回字符串 0b
hex(x) 十转十六 0x
oct(x) 十转八 0o

负数转二进制
有符号的整数第一位0表示正数，1表示负数不参与进制转换
[-128,127]最大 2**7-1(总共256)
无符号的整数 0-255(2**8-1) (总共256)
规则：按位运算是对数字的补码进行操作的
补码:对于正数原码==反码==补码一致，
        对于负数的补码需要计算
        反码 = 原码除了符号位其他位取反(0变1，1变0)
        补码 = 反码+1
十进制转为二进制,对数据的补码进行按位运算
& 按位与运算，相邻两个均为1则为1，其他则为0
| 或运算两个有1即为1，其他为0
^ 按位异或相邻两个不相同为1，相同为0
~ 按位取反每个数据进行二进制取反(包含符号位)