Python

Python

Python是用来编写应用程序的高级编程语言。Python为我们提供了非常完善的基础代码库，覆盖了网络、文件、GUI、
数据库、文本等大量内容，被形象地称作“内置电池（batteries included）”。用Python开发，许多功能不必从零
编写，直接使用现成的即可。

除了内置的库外，Python还有大量的第三方库，也就是别人开发的，供你直接使用的东西。当然，如果你
开发的代码通过很好的封装，也可以作为第三方库给别人使用。

Python适合开发哪些类型的应用呢？
首选是网络应用，包括网站、后台服务等等；
其次是许多日常需要的小工具，包括系统管理员需要的脚本任务等等；
另外就是把其他语言开发的程序再包装起来，方便使用。

优点:
跨平台
Python是跨平台的，它可以运行在Windows、Mac和各种Linux/Unix系统上。在Windows上写Python程
序，放到Linux上也是能够运行的。


缺点:
第一个缺点就是运行速度慢，和C程序相比非常慢，因为Python是解释型语言，你的代码在执行时会一
行一行地翻译成CPU能理解的机器码，这个翻译过程非常耗时，所以很慢。而C程序是运行前直接编译成
CPU能执行的机器码，所以非常快。

第二个缺点就是代码不能加密。如果要发布你的Python程序，实际上就是发布源代码，这一点跟C语言
不同，C语言不用发布源代码，只需要把编译后的机器码（也就是你在Windows上常见的xxx.exe文件）
发布出去。要从机器码反推出C代码是不可能的，所以，凡是编译型的语言，都没有这个问题，而解释型
的语言，则必须把源码发布出去。

下载安装

目前，Python有两个版本，一个是2.x版，一个是3.x版，这两个版本是不兼容的。由于3.x版越来越普及，
所以采用3.8版本，下载链接如下:
https://www.python.org/ftp/python/3.8.0/python-3.8.0-amd64.exe

下载和安装完成后，打卡CMD窗口输入python，会进入Python交互式环境中，可以输入任何Python代码，
回车后会立刻得到执行结果。

如果窗口显示：'python' is not recognized as an internal or external co│
│mmand, operable program or batch file. 

则需要在环境变量中配置python.exe的位置(参考Java JDK的配置 指定一下path即可)

Python解释器

当我们编写Python代码时，我们得到的是一个包含Python代码的以.py为扩展名的文本文件。要运行代码，
就需要Python解释器去执行.py文件。

目前python的解释器有如下几种:
1.CPython
CPython是使用最广的Python解释器。当我们从Python官方网站下载并安装好Python 3.x后，我们就直接获
得了一个官方版本的解释器：CPython。这个解释器是用C语言开发的，所以叫CPython。在命令行下运行
python就是启动CPython解释器。

2.IPython
IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执
行Python代码的功能和CPython是完全一样的。好比很多国产浏览器虽然外观不同，但内核其实都是调用了IE。

3.PyPy
PyPy是另一个Python解释器，它的目标是执行速度。PyPy采用JIT技术，对Python代码进行动态编译，
所以可以显著提高Python代码的执行速度。绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython
有一些是不同的，这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。如果你的代码要
放到PyPy下执行，就需要了解PyPy和CPython的不同点。

4.Jython
Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。

5.IronPython
IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把
Python代码编译成.Net的字节码。

运行Python

Python交互模式的代码是输入一行，执行一行,Python交互模式主要是为了调试Python代码用的，也便于
初学者学习，它不是正式运行Python代码的环境！

命令行模式下直接运行.py文件是一次性执行该文件内的所有代码.
编写一个.py文件,内容如下:print('你好，Python')

Python输入输出

#input()输入函数
name = input("请输入您的姓名:");
#print()输出函数
print("~~~~~~~~~~~~~~~~~~~~~\n");
print("键盘输出姓名:"+name);

数据类型-整数

Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，
例如：1，100，-8080，0，等等。

计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f
表示，例如：0xff00，0xa5b4c3d2，等等。

对于很大的数，例如10000000000，很难数清楚0的个数。Python允许在数字中间以_分隔，因此，写
成10_000_000_000和10000000000是完全一样的。十六进制数也可以写成0xa1b2_c3d4。

#代码展示
print(100);
print("-------");
print(-100);
print("-------");
#Python允许在数字中间以_分隔 增强可读性
print(100_00_00_00);
print("-------");
print(100000000);


输出结果:
100
-------
-100
-------
100000000
-------
100000000

注意:
Python的整数没有大小限制，而某些语言的整数根据其存储长度是有大小限制的，
例如Java对32位整数的范围限制在-2147483648-2147483647。

数据类型-浮点数

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变
的，比如，1.23x10^9和12.3x10^8是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但
是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x10^9就是1.23e9，或者
12.3e8，0.000012可以写成1.2e-5，等等。

整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是
的！），而浮点数运算则可能会有四舍五入的误差。

#代码展示
print(10.5 / 2);
print(22.0 / 2);
print(6.3 / 2.0);

输出结果
5.25
11.0
3.15

注意：
Python的浮点数也没有大小限制，但是超出一定范围就直接表示为inf（无限大）。

数据类型-字符型

字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种
表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，
那就可以用""括起来，比如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。

#代码展示
print('abc');
print("张三上山打老虎");

输出结果
abc
张三上山打老虎

数据类型-布尔类型

布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，
在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来。

布尔值可以用and、or和not运算。

#代码展示
print(True)
print(False)

print(True and True)
print(True or False)
print(not True)

输出结果
True
False
True
True
False

数据类型-空值

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

#代码展示
print(None)

输出结果
None

转义字符

转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\。

#代码展示
print('\'\'\'\'\'\'\'\'\'');
print("\"\"\"\"\"\"");
print("\n")
print("制表符")
print("\t")

输出结果

'''''''''
""""""


制表符
	

强制不转义

Python还允许用r''|r""表示''|""内部的字符串默认不转义

#代码展示
print(r'\'\'\'\'\'\'\'\'\'');
print(r"\"\"\"\"\"\"");
print(r"\n")
print(r"制表符")
print(r"\t")

#输出结果
\'\'\'\'\'\'\'\'\'
\"\"\"\"\"\"
\n
制表符
\t

格式化多行内容

如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用'''XXX'''的格式表示多
行内容。

#代码展示
print('''
你好，Python
大数据学习
未来可期
~~~~~~
''');

输入结果：

你好，Python
大数据学习
未来可期
~~~~~~

变量

变量的概念基本上和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可
以是任意数据类型。

变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和_的组合，且不能用数字开头
，比如：

#代码展示
a = 123;
print("整数变量:");
print(a);
a = "张三";
print("字符串变量:");
print(a);
a = True;
print("布尔值变量");
print(a);

输出结果

整数变量:
123
字符串变量:
张三
布尔值变量
True

注意：
这种变量本身类型不固定的语言称之为动态语言。

常量

所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名
表示常量：

PI = 3.14159265359

但事实上PI仍然是一个变量，Python根本没有任何机制保证PI不会被改变，所以，用全部大写的变量名表
示常量只是一个习惯上的用法，如果你一定要改变变量PI的值，也没人能拦住你。


#代码展示
PI = 3.14159265359;
print("PI的值:");
print(PI);
PI = 9999;
print("PI的值发生变化:")
print(PI)

输出结果

PI的值:
3.14159265359
PI的值发生变化:
9999

除法运算

在Python中，有两种除法，一种除法是：/
/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：
#代码展示
print(10 / 2);

输出结果
5.0

-------------------------------------------------------------
还有一种除法是：//
称为地板除，两个整数的除法仍然是整数：

#代码展示
print(10 // 2);
print(10 // 3);

输出结果
5
3

注意：整数的地板除永远是整数,因为地板除只取结果的整数部分。

Python字符串

在最新的Python 3版本中，字符串是以Unicode编码的，也就是说，Python的字符串支持多语言。

对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符：

#代码展示
v1 = ord('张');
print(v1);
print('\n');
print(chr(65));

输出结果
24352

A

bytes类型

Python对bytes类型的数据用带b前缀的单引号或双引号表示:
x = b'ABC'

以Unicode表示的str通过encode()方法可以编码为指定的bytes
v1 = '中文'.encode('UTF-8');
print(v1);
v2 = 'bca'.encode('ASCII');
print(v2);

输出结果
b'\xe4\xb8\xad\xe6\x96\x87'
b'bca'

注意:
纯英文的str可以用ASCII编码为bytes，内容是一样的，含有中文的str可以用UTF-8编码为bytes。
含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错。

如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，
就需要用decode()方法：

#代码展示
v1 = b'\xe4\xb8\xad\xe6\x96\x87';
print(v1.decode('UTF-8'));
v2 = b'bca';
print(v2.decode('ASCII'));


输出结果
中文
bca

注意：
如果bytes中包含无法解码的字节，decode()方法会报错

Traceback (most recent call last):
  File "E:\2021-11-12-python\project01\com\ldd\main\main.py", line 3, in <module>
    print(v1.decode('UTF-8'));
UnicodeDecodeError: 'utf-8' codec can't decode byte 0x88 in position 6: invalid start byte

如果bytes中只有一小部分无效的字节，可以传入errors='ignore'忽略错误的字节
#代码展示
v1 = b'\xe4\xb8\xad\xe6\x96\x87\x88';
print(v1.decode('UTF-8',errors='ignore'));

中文

len()函数

要计算str包含多少个字符，可以用len()函数：

#代码展示
v1 = "张三坐错车";
print(len(v1));

输出结果
5
-------------------------------------------------------

len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数：

v1 = "张三坐错车".encode('UTF-8');
print(len(v1));

输出结果
15

格式化占位符

最后一个常见的问题是如何输出格式化的字符串。我们经常会输出类似'亲爱的xxx你好！你xx月的话费是
xx，余额是xx'之类的字符串，而xxx的内容都是根据变量变化的，所以，需要一种简便的格式化字符串的
方式。

#代码展示
v1 = 'Hello %s' % 'World';
print(v1);
v2 = '%s同学,在%s，打卡出校门' % ('张三','2021-10-10 12:12:12');
print(v2);

输出结果：
Hello World
张三同学,在2021-10-10 12:12:12，打卡出校门
----------------------------------------------
#代码展示
v1 = 'Age: %s. Gender: %s' % (25,True);
print(v1);
输出结果：
Age: 25. Gender: True

注意：%s它会把任何数据类型转换为字符串
----------------------------------------------
#代码展示
v1 = '%%' % ();
print(v1);
输出结果：
%

注意: 格式化字符串 用%%来表示一个%

format函数使用

格式化字符串的方法是使用字符串的format()方法，它会用传入的参数依次替换字符串内的占位符{0}、{1}……

#代码展示
v1 = '{0}同学，最近在{1}口吐狂言'.format("张三","东营路");
print(v1);
输出结果：
张三同学，最近在东营路口吐狂言

List操作

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。

#代码展示
nameList = ['张三','李四','王五'];
print(nameList);
print(len(nameList));
print("-----------");
print(nameList[0]);
print(nameList[1]);
print(nameList[2]);
print("-----------");
print(len(nameList)-1);

输出结果:
['张三', '李四', '王五']
3
-----------
张三
李四
王五
-----------
2

1.list是一个可变的有序表，所以，可以往list中追加元素到末尾。

#代码展示
nameList = ['张三','李四','王五'];
nameList.append("马六");
nameList.append("牛七")
print(nameList);
输出结果：
['张三', '李四', '王五', '马六', '牛七']

2.insert把元素插入到指定的位置
#代码展示
nameList = ['张三','李四','王五'];
nameList.insert(0,"爸一");
nameList.insert(1,"爸二");
print(nameList);

输出结果：
['爸一', '爸二', '张三', '李四', '王五']

3.要删除list末尾的元素，用pop()方法,要删除指定位置的元素，用pop(i)方法，其中i是索引位置

#代码展示
nameList = ['张三','李四','王五'];
nameList.pop();
print(nameList);
print("-----------");
nameList.pop(0);
print(nameList);


输出结果:
['张三', '李四']
-----------
['李四']

4.list其他操作

#代码展示
nameList = ['张三','李四','王五'];
#要把某个元素替换成别的元素，可以直接赋值给对应的索引位置
nameList[0] = "张子墨";
print(nameList);
print("----------");

#list里面的元素的数据类型也可以不同
varList = ["Hello",100,True,False,200.20];
print(varList);
print("----------");
#list元素也可以是另一个list
allList = ["Hello",["张三",100,True,["张思",200,False]],"World"];
print(allList);

#获取allList
#allList[1]里面第一个数组,allList[1][3]第一个数组里面的数组,allList[1][3][0]张思
print(allList[1][3][0]);

输出结果:

['张子墨', '李四', '王五']
----------
['Hello', 100, True, False, 200.2]
----------
['Hello', ['张三', 100, True, ['张思', 200, False]], 'World']
张思

#代码展示
nullList = [];
#如果一个list中一个元素也没有，就是一个空的list，它的长度为0
print(nullList);
print(len(nullList));

输出结果:
[]
0

tuple

tuple有序列表叫元组,tuple和list非常类似，但是tuple一旦初始化就不能修改。

它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的。

#代码展示
nameTuple = ("张三","李四","王五");
print(nameTuple);
print(nameTuple[0]);
print(nameTuple[1]);
print("-----------");
#定义一个空的tuple，可以写成()
varTuple = ();
print(varTuple);
print("-----------");
#定义只有一个元素的tuple
#定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产
生了歧义，
#因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
#oneTuple = (1);
oneTuple = (1,);
print(oneTuple);
print(len(oneTuple));
print(oneTuple[0]);

输出结果:

('张三', '李四', '王五')
张三
李四
-----------
()
-----------
(1,)
1
1

注意：tuple的不可变表示tuple内部元素指向不可变。比如说tuple里面存入的是一个list，你不能把这个
list变成字符串或者数据，但是list内部中的元素可以发生改变(懒的写案例了)

if判断

#代码展示
age = 10;
if age > 5:
    print("你的年龄超过5岁");
    print("现在通知您,");
    print("赶紧买票");


----------------------------

#代码展示
age = 1;
if age > 5:
    print("你的年龄超过5岁");
    print("现在通知您,");
    print("赶紧买票");
else:
    print("您的年龄没有超过5岁");
    print("可以不用买票");

----------------------------

#代码展示
age = 6;
if age > 5:
    print("你的年龄超过5岁");
elif age > 6:
    print("您的年龄超过6岁");
elif age > 7:
    print("您的年龄超过7岁");
else:
    print("未知年龄");


输出结果:

你的年龄超过5岁

注意:
if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略
掉剩下的elif和else。

if判断条件还可以简写，只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False。

#代码展示
x = 1;
if x:
    print("摇摇晃晃");

int()函数

#代码展示
x = "123";
print(x);
#int()函数，将字符串转成int
print(int(x));

for in循环遍历

#代码展示
nameList = ["张三","李四","王五"];
for name in nameList:
    print("name:"+name);

#range(10) 产生从0开始 小于10的整数序列 0~9
#list()函数将整数序列，转换成list
numberList = list(range(10));
numSum = 0;

for num in numberList:
    numSum +=num;
print("0~9数值总和是:"+str(numSum));

输出结果:

name:张三
name:李四
name:王五

0~9数值总和是:45

while循环遍历

#代码展示
num = 99;
sum = 0;
while num >0:
    sum +=num;
    num -=2;
print(sum);

输出结果:
2500
-----------------------------------------------
#代码展示
num = 99;
sum = 0;
while num >0:
    if num == 97:
        break
    sum +=num;
    num -=2;
print(sum)

输出结果：
99
-----------------------------------------------
#代码展示
num = 99;
sum = 0;
while num >0:
    if num % 2 ==0:
        continue
    sum +=num;
    num -=2;

print(sum)
输出结果：
2500

dict数据结构

1.Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值
（key-value）存储，具有极快的查找速度。
2.dict在内部可以直接计算出key对应存放value的“页码”，所以速度非常快。这种key-value存储方式，
在放进去的时候，必须根据key算出value的存放位置，这样，取的时候才能根据key直接拿到value。


dict有以下几个特点：
1.查找和插入的速度极快，不会随着key的增加而变慢。
2.需要占用大量的内存，内存浪费多。
3.dict的key必须是不可变对象。
4.这个通过key计算位置的算法称为哈希算法（Hash）。
5.在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。


#代码展示
dictMap = {"name":"张三","age":18,"hobby":["篮球","游戏","吉他"]};
print(dictMap);
print(dictMap.get("name"));
print(dictMap.get("hobby"));

#把数据放入dict的方法，除了初始化时，还可以通过key放入
dictMap["name"] = "李四";
print(dictMap["name"]);
#由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉
dictMap["name"] = "王五";
dictMap["name"] = "马六";
print(dictMap.get("name"));

输出结果:
{'name': '张三', 'age': 18, 'hobby': ['篮球', '游戏', '吉他']}
张三
['篮球', '游戏', '吉他']
李四
马六

#代码展示
dictMap = {"name":"张三","age":18,"hobby":["篮球","游戏","吉他"]};
#通过in判断key是否存在
print("name" in dictMap);
#通过dict提供的get()方法，如果key不存在，可以返回None或者自己指定的value
print(dictMap.get("hello"));
print(dictMap.get("hello","key不存在"));

#要删除一个key，用pop(key)方法，对应的value也会从dict中删除
dictMap.pop("name");
print(dictMap.get("name"));

输出结果:

True
None
key不存在
None

Set

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

#代码展示
#重复元素在set中自动被过滤
#显示的顺序也不表示set是有序的
nameSet = set(["张三","李四","张三"]);
print(nameSet);
print("--------------");
nameSet.add("王五");
nameSet.add("赵六");
nameSet.add("赵六");
print(nameSet);
print("--------------");
nameSet.remove("张三");
print(nameSet);

输出结果:

{'张三', '李四'}
--------------
{'王五', '张三', '李四', '赵六'}
--------------
{'王五', '李四', '赵六'}

#代码展示
nameOneSet = set(["张三","李四","张三"]);
nameTwoSet = set(["赵六","李四","马飞飞"]);
#set做交集
print(nameOneSet & nameTwoSet);
print("---------------------");
#set做并集
print(nameOneSet | nameTwoSet);

输出结果:

{'李四'}
---------------------
{'赵六', '马飞飞', '张三', '李四'}

内置函数

#代码展示
#常用内置函数
#绝对值
print(abs(100));
print(abs(-30));
#最大值
print(max(100,200,300,400,500));
#数据类型转换
print(int("123"));
print(float("12.34"));
print(str("1.34"));
print(bool(1));
print(bool(0));
print(bool(''));

输出结果:

100
30
500
123
12.34
1.34
True
False
False

自定义函数

#定义自定义函数
def showModd(name):
    return name+"心情贼差劲";
print(showModd("大马猴"));
print("---------");

#如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return;
def noneReturn():
    return;
print(noneReturn());
print("---------");

#定义一个空函数，实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个
pass，让代码能运行起来。

def nop():
    pass;
print(nop());

输出结果:
大马猴心情贼差劲
---------
None
---------
None

isinstance类型判断函数

num = "123";
if not isinstance(num,(int,float)):
    print("num类型不属于int或float");
else:
    print("num类型属于int或float");

输出结果：
num类型不属于int或float

自定义函数-返回多个值

def mostParam():
    return "张三",123,["李四","王五"];

x,y,z = mostParam();
print(x);
print(y);
print(z);
print("----------");
print(mostParam());
print(mostParam()[0]);
print(mostParam()[1]);

输出结果:
张三
123
['李四', '王五']
----------
('张三', 123, ['李四', '王五'])
张三
123

注意:Python函数返回的仍然是单一值，这种多参数的返回，其实是返回一个tuple类型，按位置赋给对应的值。

定义函数-默认参数

#定义函数 y默认值为3
def defaultParam(x,y=3):
    return  x * y;

#defaultParam(2),未传入参数y,将会使用默认值。
print(defaultParam(2));
print("--------------");
print(defaultParam(2,3));


#指定参数名称传递默认参数
def defaultMoreParam(name,age=18,city="北京",sex="男"):
    print("姓名:"+name+",年龄:"+str(age)+",城市:"+city+",性别:"+sex);
#city使用传递的值，age,sex使用默认值 (这种通过参数名指定的方式，不用考虑默认参数的位置)    
defaultMoreParam("张三",city='西安');

输出结果:
6
--------------
6
姓名:张三,年龄:18,城市:西安,性别:男

def defaultParam(list = []):
     list.append("end");
     return list;

print(defaultParam([1,2,3]));
print("-------------------");


#注意：因为默认参数list也是一个变量，它指向对象[]，每次调用该函数，如果改变了list的内容，则下次
调用时，默认参数的内容就变了，不再是函数定义时的[]了。
print(defaultParam());
print(defaultParam());
print(
																				

						

							上一篇：							
								详细解释 Python 本地语言的陷阱							
						
						

							下一篇：							
								ubuntu蟒蛇调用C/C++动态链接库的方法详解							
						
					
															

						

							推荐阅读						
						

														

								
									

										python 机器人编程 - 使用 python API 调用控制 wifi 小车的示例程序									
								
							
														

								
									

										Python 教程：Python 中的集合及其对集合的所有操作									
								
							
														

								
									

										模块编译成功，但 python 运行时找不到依赖项 名称为''的模块									
								
							
														

								
									

										Python 编程：常用模块分类组织									
								
							
														

								
									

										Python -- 爬虫小说学习 -- 仅供个人娱乐 -- III.									
								
							
														

								
									

										每日 Python 工具包 [Celery]。									
								
							
														

								
									

										LeetCode] 动态编程 - 95.动态编程 - 95.不同的二叉搜索树 II（附完整 Python/C++ 代码） - 基本思想									
								
							
														

								
									

										基于卷积神经网络、resnet50、mobilenet 模型的蔬菜识别系统 [pytorch 框架+python 源代码									
								
							
														

								
									

										屏幕录制功能的 Python 实现									
								
							
														

								
									

										[Python 数据可视化] 用 Matplotlib 绘制精美的图表！