Python

持续更新

基础

变量相关

• Numbers（数字）

  • int（有符号整型） Python3.X 版本中 long 类型被移除，使用 int 替代。
  • float（浮点型）
    • float(‘inf’) 表示正无穷 -float(‘inf’) 或 float(‘-inf’) 表示负无穷 其中，inf 均可以写成 Inf
  • complex（复数）复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。

• String（字符串）

  • u/U:表示unicode字符串
    不是仅仅是针对中文, 可以针对任何的字符串，代表是对字符串进行unicode编码。
    一般英文字符在使用各种编码下, 基本都可以正常解析, 所以一般不带u；但是中文, 必须表明所需编码, 否则一旦编码转换就会出现乱码。
    建议所有编码方式采用utf-8，即在py文件开头添加: # coding: utf-8

  • r/R:非转义的原始字符串
    与普通字符相比，其他相对特殊的字符，其中可能包含转义字符，即那些，反斜杠加上对应字母，表示对应的特殊含义的，比如最常见的”\n”表示换行，”\t”表示Tab等。而如果是以r开头，那么说明后面的字符，都是普通的字符了，即如果是“\n”那么表示一个反斜杠字符，一个字母n，而不是表示换行了。
    以r开头的字符，常用于正则表达式，对应着re模块。

  • F-strings python3.6开始支持，类似js的模板字符串

    str_p = f'顺子是{add_string(str)}'

• List（列表）

• Tuple（元组）

• Dictionary（字典），类似js的map和object结合，键值可以为字符串也可以为number

None 是 NoneType 数据类型的唯一值

python中除号用/表示，但是和C语言不同的是/得到的值总是浮点数，// 两数相除，向下取整

未声明为非局部变量的变量是只读的，（写入只读变量会在最内层作用域中创建一个 新的 局部变量，而同名的外部变量保持不变。）

空字符串、空列表、空元组、空字典、空集合均为false

内置类型

https://docs.python.org/zh-cn/3/library/stdtypes.html?highlight=maketrans#text-sequence-type-str

数字类型 — int, float, complex

迭代器类型 — 生成器generator

序列类型 — list, tuple, range¶

文本序列类型 — str¶

二进制序列

集合类型 — set，frozenset

映射类型 — dict

…

常用函数

list() 可以直接把字符串转为字符数组，split方法则不行

chr()函数取整数值作为Unicode码转换为字符，ord() 获取单个字符输出 Unicode 码

操作符

基础语句

• yield语句：与 return 的差别在于会保留执行状态，下次调用会从上次执行点继续执行

• if 、elif 、else条件控制语句

  支持a<x<b这种连比

• 循环语句：

  • while……else

  • for循环，start默认为0，step默认为1，<stop，不会等于stop

    for i in range(satrt, stop, step):
        业务逻辑

  pass 语句 是 Python 中的空语句，程序执行到此语句直接跳过，不会做任何的操作，仅作占位语句，但它在保持程序结构的完整性方面，有一定价值。

  • 列表推导式效率远高于for循环语句

    out_list = [表达式 for 变量 in 列表 条件判断语句等]

    >>> out_list = [i**2 for i in range(10) if i % 2 ==0]
    >>> out_list
    [0, 4, 16, 36, 64]

• match…case

  • 变量名 _ 作为 通配符 并确保目标将总是被匹配，是可选的，如果没有又之前 case 未得到匹配，则会执行一个空操作（no-op）

• try…except…as… 捕获异常

  try:
      a=1+"b"
  except Exception as e:
      print(e)

• lambda函数

  lambda arg1,arg2,arg3… :<表达式>
  
  lambda x, y: x*y；函数输入是x和y，输出是它们的积x*y
  
  lambda:None；函数没有输入参数，输出是None
  
  lambda *args: sum(args); 输入是任意个数的参数，输出是它们的和(隐性要求是输入参数必须能够进行加法运算)
  
  lambda **kwargs: 1；输入是任意键值对参数，输出是1

数据值传递和引用

字符串，数值，元组均为静态变量，列表，字典为动态变量。一般静态变量值传递为拷贝，动态变量值传递为引用。利用 id() 可以查看变量存储地址。

注：对静态变量首次传递时也是引用，当需要修改静态变量时，因为静态变量不能改变，所以需要生成一个新的空间存储数据。

所以更准确地说，python中只有引用传递，只不过静态类型不可改变，要改变对应名称的值只能改变其指向的内存地址。

is比较的是两个对象的内存地址是否相等，==比较的是两个对象的值是否相等。

a = 1
b = 1
a == b # True
a is b # True

a = 888
b = 888
a == b # True
a is b # False

a = 'hello'
b = 'hello'
a is b # True
a == b # True

a = 'hello world'
b = 'hello world'
a == b # True
a is b # False

部分代表小整数的对象都会指向小整数池，类似的，Python解释器中使用了 intern（字符串驻留），使值同样的字符串对象仅仅会保存一份，放在一个字符串储蓄池中，是共用的，如果字符串中有空格，默认不启用intern机制。对字符串储蓄池中的字符串使用 is 和 == 比较会得到相同的结果。

在shell中，仅有以下划线、数字、字母组成的字符串会被intern。而pycharm中只要是同一个字符串不超过20个字符都被加入到池中

需要严格根据解释环境判断，在IDLE中id都一样。

垃圾回收：引用计数，当某个对象在其作用域内不再被其他对象引用的时候，Python 就自动清除对象；

注意深浅拷贝：

• a.append(tmp) a.append(tmp[:])

切片

切片使用2个冒号分隔的3个数字来完成：

• 第一个数字表示切片的开始位置，默认为0
• 第二个数字表是切片的截止（但不包含）位置（默认为列表长度）
• 第三个数字表示切片的步长(默认为1)，当步长省略时，顺便可以省略最后一个冒号。

a[:]是深复制，a是浅复制，相当于赋值a的话是赋值了指针，赋值a[:]相当于复制了a对应的那段空间

解包

解包赋值，是zip函数的逆操作。

基础数据结构类型

效率

list查询是O(n), set是O(1)

增删list到最后一个(append, pop)是O(1), 其他的为O(n), set的增删是O(1)

详见https://wiki.python.org/moin/TimeComplexity

list

中括号[]创建一个列表，列表内可含有各种不同类型，包括再嵌套列表。

方法

• append一次添加1个元素，insert在指定位置添加元素

a.insert(2,5) # insert 在索引2处添加元素5

• remove直接删除元素，若被删除元素在列表内重复出现多次，则只删除第一次

• pop方法若不带参数默认删除列表最后一个元素；若带参数则删除此参数代表的索引处的元素

• remove方法

  移除列表第一个匹配项

#移除list1中第一个值为1的项
list1.remove(1)

• extend方法

  list.extend(L)

  通过将所有元素追加到已知list来扩充它，相当于a[len(a):]= L

列表封装的其他方法还包括如下：

`clear`,`index`,`count`,`sort`,`reverse`,`copy

tuple

元组是一类不允许添加删除元素的特殊列表，也就是一旦创建后续决不允许增加、删除、修改。

()创建元组。

set

基本用法 set是一种里面不能含有重复元素的数据结构，这种特性天然的使用于列表的去重。

创建set

此为python2语法

>>>x = set('runoob')
>>> y = set('google')
>>> x, y
(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除

>>> x = set('eleven')
>>> y = set('twelve')
>>> x,y
({'l', 'e', 'n', 'v'}, {'e', 'v', 'l', 't', 'w'})
>>> x & y  #交集
{'l', 'e', 'v'}
>>> x | y  #并集
{'e', 'v', 'n', 'l', 't', 'w'}
>>> x - y  #差集
{'n'}
>>> y -x   #差集
{'t', 'w'}
>>> x ^ y  #补集
{'t', 'n', 'w'}
>>> y ^ x  #补集
{'w', 'n', 't'}

python3中，除了可以使用 set 构造器，非空的 set (不是 frozenset) 还可以通过将以逗号分隔的元素列表包含于花括号之内来创建，例如: {'jack', 'sjoerd'}。

方法

摘自菜鸟教程，可能过时，建议查看python doc

dict

键值可以为数字、字符串甚至是元祖

字典可用多种方式来创建:

• 使用花括号内以逗号分隔 键: 值 对的方式: {'jack': 4098, 'sjoerd': 4127} or {4098: 'jack', 4127: 'sjoerd'}
• 使用字典推导式: {}, {x: x ** 2 for x in range(10)}
• 使用类型构造器: dict(), dict([('foo', 100), ('bar', 200)]), dict(foo=100, bar=200)

元组可以作为 dict 的 key，但列表不能作为元组的 key。这是由于 dict 要求 key 必须是不可变类型，但列表是可变类型，因此列表不能作为元组的 key。

items()、keys()、values() 分别用于获取字典中的所有 key-value 对、所有 key、所有 value。这三个方法依次返回 dict_items、dict_keys 和 dict_values 对象，Python 不希望用户直接操作这几个方法，但可通过 list() 函数把它们转换成列表。

• dict.has_key(key)
  如果键在字典dict里返回true，否则返回false
• dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值

deque

collections.deque()

class collections.``deque([iterable[, maxlen]])

• append(x)

  添加 x 到右端。

• appendleft(x)

  添加 x 到左端。

• pop()

  移去并且返回一个元素，deque 最右侧的那一个。 如果没有元素的话，就引发一个 IndexError。

• popleft()

  移去并且返回一个元素，deque 最左侧的那一个。 如果没有元素的话，就引发 IndexError。

• Deque对象同样提供了一个只读属性:

  • maxlen

    Deque的最大尺寸，如果没有限定的话就是 None 。

Counter

OrderedDict

collections. 有序字典

heapq

defaultdict

ChainMap

常用函数、方法

a = '123456'
a[2:3]
//'3' 冒号前包后不包

string.isdigit() 	
//如果 string 只包含数字则返回 True 否则返回 False.

enumerate()

遍历列表(数组)，可以同时获取索引和值，下面是例子

arr1 = ["a","b","c","d"]
for index,value in enumerate(arr1):
	print(index,value)

# 结果
0 a
1 b
2 c
3 d

json模块

把字符串转换成字典对象json.loads()

把对象转换成字符串json.dumps()

json.dump(data,file)把字典对象转换成字符串并写入文件

字符串转换成字典对象时，字符串里只能使用双引号

‘’.join() 拼接字符串

arr =["a","b","c"]
arr_str = "-".join(arr)
print(arr_str)

# 输出结果 a-b-c

''.join(chain(*mat))//拼接二维矩阵

math.comb()

Python中的method方法用于获取从n个项目中选择k个项目(不重复且无顺序)的方法数量

os.path.split(‘PATH’)

以 “PATH” 中最后一个 ‘/‘ 作为分隔符，分隔后，将索引为0的视为目录（路径），将索引为1的视为文件名

print

print(i,end=’\n’)，可指定末尾字符，默认为换行

product

product(A,B)函数,返回A和B中的元素组成的笛卡尔积的元组,具体见如下代码:

import itertools
for item in itertools.product([1,2,3,4],[100,200]):
    print(item)
    '''
(1, 100)
(1, 200)
(2, 100)
(2, 200)
(3, 100)
(3, 200)
(4, 100)
(4, 200)
    '''
12345678910111213

product(list1,list2)依次取出list1中每1个元素,与list2中的每1个元素,组成元组,将所有元组组合成一个列表返回.

round()

四舍五入取整

sort

Python 列表有一个内置的 list.sort() 方法可以直接修改列表。还有一个 sorted() 内置函数，它会从一个可迭代对象构建一个新的排序列表

class Student:
    def __init__(self, name, grade, age):
        self.name = name
        self.grade = grade
        self.age = age
    def __repr__(self):
        return repr((self.name, self.grade, self.age))

student_objects = [
    Student('john', 'A', 15),
    Student('jane', 'B', 12),
    Student('dave', 'B', 10),
]

Operator 模块函数

上面显示的键函数模式非常常见，因此 Python 提供了便利功能，使访问器功能更容易，更快捷。 operator 模块有 itemgetter() 、 attrgetter() 和 methodcaller() 函数。

使用这些函数，上述示例变得更简单，更快捷：

>>> from operator import itemgetter, attrgetter

>>> sorted(student_tuples, key=itemgetter(2))
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

>>> sorted(student_objects, key=attrgetter('age'))
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

Operator 模块功能允许多级排序。 例如，按 grade 排序，然后按 age 排序：

>>> sorted(student_tuples, key=itemgetter(1,2))
[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]

>>> sorted(student_objects, key=attrgetter('grade', 'age'))
[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]

升序和降序

list.sort() 和 sorted() 接受布尔值的 reverse 参数。这用于标记降序排序。 例如，要以反向 age 顺序获取学生数据：

>>> sorted(student_tuples, key=itemgetter(2), reverse=True)
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

>>> sorted(student_objects, key=attrgetter('age'), reverse=True)
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

排序稳定性和排序复杂度

排序保证是 稳定 的。 这意味着当多个记录具有相同的键值时，将保留其原始顺序。

str.isalpha()

字符串是否为字母

str.maketrans(intab.outtab)

• intab – 字符串中要替代的字符组成的字符串。
• outtab – 相应的映射字符的字符串。

内建函数: bytearray.maketrans()、bytes.maketrans()、str.maketrans()

通常和 translate 方法配合使用

#!/usr/bin/python3
 
intab = "aeiou"
outtab = "12345"
deltab = "thw"
 
trantab1 = str.maketrans(intab,outtab) # 创建字符映射转换表
trantab2 = str.maketrans(intab,outtab,deltab) #创建字符映射转换表，并删除指定字符
 
test = "this is string example....wow!!!"
 
print(test.translate(trantab1))
print(test.translate(trantab2))

str.split()

语法：str.split(str=” “,num=string.count(str))

参数说明：
str： 表示为分隔符，默认为空格，但是不能为空串。若字符串中没有分隔符，则把整个字符串作为列表的一个元素。
num：表示分割次数。如果存在参数num，则仅分隔成 num+1 个子字符串。

默认空格分隔时会忽略分割后的空串，包括\n\t\r （\r\n表示回车换行）

s.split('.',-1) #尽可能多的分隔，与不加num参数相同

注意：str为不可变对象，所以此方法不会修改原对象，若需处理分割后的字符串需要转储返回值

sNew = str.split()

str.strip([chars])

strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。

还有lstrip和rstrip，去除头部或尾部

* 和 **

• *args：argument用于列表、元组、集合
• **kwargs：kwargument用于字典

1.解包可迭代对象

nums1=[*nums1,*nums2]
nums1+=nums2
nums1.extend(nums2)

2.函数可变参数

regex

python3.9文档https://docs.python.org/zh-cn/3.9/library/re.html?highlight=re#module-contents

re.findall(pattern, string, flags=0)

返回字符串中模式的所有非重叠匹配项，作为字符串列表或元组。该字符串从左到右扫描，并按找到的顺序返回匹配项。结果中包含空匹配项。

结果取决于模式中捕获组的数量。如果没有组，则返回匹配整个模式的字符串列表。如果只有一个组，则返回匹配该组的字符串列表。如果存在多个组，则返回与组匹配的字符串元组列表。非捕获组不影响结果的形式。

>>>re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10')
[('width', '20'), ('height', '10')]

re.sub(pattern, repl, string, count=0, flags=0)

返回通过使用 repl 替换在 string 最左边非重叠出现的 pattern 而获得的字符串。 如果样式没有找到，则不加改变地返回 string。 repl 可以是字符串或函数；如为字符串，则其中任何反斜杠转义序列都会被处理。 也就是说，\n 会被转换为一个换行符，\r 会被转换为一个回车符，依此类推。 未知的 ASCII 字符转义序列保留在未来使用，会被当作错误来处理。 其他未知转义序列例如 \& 会保持原样。 向后引用像是 \6 会用样式中第 6 组所匹配到的子字符串来替换。 例如:

>>> re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):',
...        r'static PyObject*\npy_\1(void)\n{',
...        'def myfunc():')
'static PyObject*\npy_myfunc(void)\n{'

如果 repl 是一个函数，那它会对每个非重复的 pattern 的情况调用。这个函数只能有一个 匹配对象 参数，并返回一个替换后的字符串。比如

>>> def dashrepl(matchobj):
...     if matchobj.group(0) == '-': return ' '
...     else: return '-'
>>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')
'pro--gram files'
>>> re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)
'Baked Beans & Spam'

样式可以是一个字符串或者一个 样式对象 。

可选参数 count 是要替换的最大次数；count 必须是非负整数。如果省略这个参数或设为 0，所有的匹配都会被替换。 样式的空匹配仅在与前一个空匹配不相邻时才会被替换，所以 sub('x*', '-', 'abxd') 返回 '-a-b--d-' 。

在字符串类型的 repl 参数里，如上所述的转义和向后引用中，\g<name> 会使用命名组合 name，（在 (?P<name>…) 语法中定义） \g<number> 会使用数字组；\g<2> 就是 \2，但它避免了二义性，如 \g<2>0。 \20 就会被解释为组20，而不是组2后面跟随一个字符 '0'。向后引用 \g<0> 把 pattern 作为一整个组进行引用。

re.subn(pattern, repl, string, count=0, flags=0)¶

行为与 sub() 相同，但是返回一个元组 (字符串, 替换次数).

作用域

nonlocal 语句会使得所列出的名称指向之前在最近的包含作用域中绑定的除全局变量以外的变量。

global 语句是作用于整个当前代码块的声明。 它意味着所列出的标识符将被解读为全局变量。 要给全局变量赋值不可能不用到 global 关键字，不过自由变量也可以指向全局变量而不必声明为全局变量。

在 global 语句中列出的名称不得在同一代码块内该 global 语句之前的位置中使用。

在 global 语句中列出的名称不能被定义为形式参数，也不能被作为 with 语句或 except 子句的目标，以及 for 循环的目标列表、class 定义、函数定义、import 语句或变量标注等等。

def scope_test():
    def do_local():
        spam = "local spam"

    def do_nonlocal():
        nonlocal spam
        spam = "nonlocal spam"

    def do_global():
        global spam
        spam = "global spam"

    spam = "test spam"
    do_local()
    print("After local assignment:", spam)
    do_nonlocal()
    print("After nonlocal assignment:", spam)
    do_global()
    print("After global assignment:", spam)

scope_test()
print("In global scope:", spam)

输出：
After local assignment: test spam
After nonlocal assignment: nonlocal spam
After global assignment: nonlocal spam
In global scope: global spam

可迭代对象，迭代器，生成器

常见可迭代对象

1. 集合或序列类型（如list、tuple、set、dict、str）
2. 文件对象
3. 在类中定义了__iter__()方法的对象，可以被认为是 Iterable对象，但自定义的可迭代对象要能在for循环中正确使用，就需要保证__iter__()实现必须是正确的（即可以通过内置iter()函数转成Iterator对象。iter()函数是能够将一个可迭代对象转成迭代器对象，然后在for中使用）
4. 在类中实现了如果只实现__getitem__()的对象可以通过iter()函数转化成迭代器但其本身不是可迭代对象。所以当一个对象能够在for循环中运行，但不一定是Iterable对象。

可迭代对象（Iteratable Object） 是能够一次返回其中一个成员的对象，都构建了 __iter__ 方法

迭代器（Iterator） 是同时实现__iter__() 与 __next__() 方法的对象。

class IterObj:

    def __init__(self):
        self.a = [3, 5, 7, 11, 13, 17, 19]

        self.n = len(self.a)
        self.i = 0

    def __iter__(self):
        return iter(self.a)

    def __next__(self):
        while self.i < self.n:
            v = self.a[self.i]
            self.i += 1
            return v
        else:
            self.i = 0
            raise StopIteration()

定义生成器两种方法：

1. 列表生成器——生成器表达式
2. 使用yield定义生成器函数——生成器函数

Python 中，包含 yield 关键词的普通函数就是生成器。

定义二维数组

list_three = [[0 for i in range(3)] for j in range(3)]

类

对象方法、静态方法、类方法等，归属权分别为obj、cls、cls

基础

当（从结尾处）正常离开类定义时，将创建一个 类对象。 这基本上是一个包围在类定义所创建命名空间内容周围的包装器，原始的（在进入类定义之前起作用的）局部作用域将重新生效，类对象将在这里被绑定到类定义头所给出的类名称

任何形式为 __spam 的标识符（至少带有两个前缀下划线，至多一个后缀下划线）的文本将被替换为 _classname__spam，其中 classname 为去除了前缀下划线的当前类名称。 这种改写不考虑标识符的句法位置，只要它出现在类定义内部就会进行。__init__类似构造函数

class Student(object):
    ...

    def set_score(self, score):
        self.__score = score

以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用__name__、__score__这样的变量名

t.ppr()等同于Test.ppr(t)

class Test:
    def ppr():
        print(self)

t = Test()
t.ppr() #Test.ppr(t)

#没有传参数，error:
Traceback (most recent call last):
  File "cl.py", line 6, in <module>
    t.ppr()
TypeError: ppr() takes 0 positional arguments but 1 was given

ins，用来表示调用它的类实例

cls，类

类本身的方法是函数对象，实例的方法是方法对象，实现原理如下：

​ 当一个实例的非数据属性被引用时，将搜索实例所属的类。 如果被引用的属性名称表示一个有效的类属性中的函数对象，会通过打包（指向）查找到的实例对象和函数对象到一个抽象对象的方式来创建方法对象：这个抽象对象就是方法对象。 当附带参数列表调用方法对象时，将基于实例对象和参数列表构建一个新的参数列表，并使用这个新参数列表调用相应的函数对象。

类的继承

class Parent:
    def pprt(self):
        print(self)

class Child(Parent):
    def cprt(self):
        print(self)
c = Child()
c.cprt()
c.pprt()
p = Parent()
p.pprt()

#output:
<__main__.Child object at 0x0000000002A47080>
<__main__.Child object at 0x0000000002A47080>
<__main__.Parent object at 0x0000000002A47240>

类中的方法：

• __init__方法的第一参数永远是self，表示创建的类实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。（2）、有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器会自己把实例变量传进去：

也分实例属性和类属性，后者所有实例共享

实例属性访问优先级比类属性高

千万不要在实例上修改类属性，它实际上并没有修改类属性，而是给实例绑定了一个实例属性。

其它

解释器信息

#!/usr/bin/python

分成两种情况：

（1）如果调用 python 脚本时，使用:

python script.py 

#!/usr/bin/python 被忽略，等同于注释

（2）如果调用python脚本时，使用:

./script.py 

#!/usr/bin/python 指定解释器的路径

PS：shell 脚本中在第一行也有类似的声明。

复杂类型注解

List[int]即由int组成的列表，但是，实际中，只要这个列表中存在nt（其他的可以为任何类型），就不会出现警告

模块信息

__name__

直接执行一段脚本的时候，这段脚本的 **name**变量等于 ‘main‘，当这段脚本被导入其他程序的时候，name 变量等于脚本本身的名字。

环境

anaconda

一、先创建一个新的虚拟环境

conda create –name my_test python=3.7#创建一个名称为my_test的虚拟环境

二、激活虚拟环境

activate my_test

三、切换环境

conda info –env可以看到所有python环境，前面有个‘*’的代表当前环境：

1、查看已有的虚拟环境

conda env list

2、切换到想要的虚拟环境，这里我切换到my_test

conda activate my_test

3、在当前环境里安装ipykernel

conda install ipykernel

4、python -m ipykernel install –name my_test

5、打开jupyter新建一个notebook,如下所示：

克隆产生新环境，移除旧环境达到更改环境名称的目的

conda create –name python32（新名字） –clone python321（老名字）

conda remove –name old_name –all

mamba

替代 conda 的包管理系统

Geemap has several optional dependencies, such as GeoPandas, localtileserver, osmnx, rioxarray and rio-cogeo. It can be a bit cumbersome to install these optional dependencies individually. Luckily, these optional dependencies are available through the pygis Python package, which can be installed with a single command. Since pygis has many dependencies, sometimes it can take a while for conda to resolve dependencies. Therefore, we highly recommend you to install Mamba, a fast, robust, and cross-platform package manager. It runs on Windows, macOS, and Linux, and is fully compatible with conda packages and supports most of conda’s commands. The following commands install Mamba and pygis:

conda install -c conda-forge mamba
mamba install -c conda-forge geemap pygis