Python 学习

在后台项目中涉及到了 python 模块，再次被迫无奈学习了 python 相关知识

环境搭建

首先要搭建一个 python 环境，就不能直接下载 python。Anaconda 是一个开源的 Python 发行版本，其包含了 conda、Python 等180多个科学包及其依赖项。它可以用于在同一个机器上安装不同版本的软件包及其依赖，并能够在不同的环境之间切换

它允许我们创建一个虚拟环境，在虚拟环境下搭建安装 python 的环境，比直接安装 python 简单

环境 = “好比一栋楼，在楼里面分配一间屋给各种‘包’放，每间房里面的‘包’互不影响”

激活环境 = “告诉电脑，我现在要用这个屋子里面的‘包’来做东西了所以要进这间屋子”

移除环境 = “现在这个屋子里面我原来要用的东西现在不需要了把它赶出去节省电脑空间”

Conda 创建环境相当于创建一个虚拟的空间将这些包都装在这个位置，我不需要了可以直接打包放入垃圾箱，同时也可以针对不同程序的运行环境选择不同的 conda 虚拟环境进行运行。这里的不需要的工具，指的就是 python 包

在执行 py 项目时，我们需要先切换到对应的环境，然后下载依赖，为项目配置对应的 py 解释器，最后才可以运行项目

conda 基础命令

-- 查看 conda 版本，也可以用于查看是否安装好了 conda
conda --version

-- 查看所有的环境
conda env list

-- 查看所有的 py 包的信息，查看环境中现有的包。相当于清点一下我买了多少工具
conda list
pip list

-- 创建环境，指定 py 版本
conda create -n proname python=3.8
conda create --name proname python=3.8

-- activate 能将我们引入 anaconda 设定的虚拟环境中
-- 如果你后面什么参数都不加那么会进入 anaconda 自带的 base 环境
conda activate python34 

-- 退出当前base环境
conda deactivate

-- 卸载环境
conda remove --name test --all

-- 下载安装 requests 包
conda install requests

-- 如果报 CondaHTTPError，说明我们的镜像需要更换了，添加新镜像
conda config --add channels http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/win-64/

-- 查看添加的镜像
conda config --show-sources

-- 删除旧镜像
conda config --remove channels 源名称或链接 

python 基础命令

我们一般使用 conda 下载所需要的包，但是也可以使用 pip 下载。接下来我们需要使用 python 下载所需要的包

-- 查看 py 版本
python -V

-- 下载安装 requests 包
pip install requests

-- 通过文件下载包
pip install -r requirements

-- 镜像下载
pip install -r requirements -i https://mirrors.aliyun.com/pypi/simple

-- 整个环境下的安装包都保存到 requirements.txt 中
pip freeze > requirements.txt

-- 卸载第三方包
conda remove requests
pip uninstall requests

-- 有些时候会报找不到对应包的问题，这时候应该升级一下包的版本
pip install --upgrade psycopg2
pip install --upgrade psycopg2==2.7.5

-- 升级或者降级 py 版本
conda install python=3.8

我们在下载的时候可能会失败，这时候需要修改下载包的镜像

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

国内常用镜像

-- 清华镜像
https://pypi.tuna.tsinghua.edu.cn/simple
-- 中科大镜像
https://pypi.mirrors.ustc.edu.cn/simple
-- 豆瓣镜像
http://pypi.douban.com/simple/
-- 阿里镜像
https://mirrors.aliyun.com/pypi/simple/

内置模块：Python 中，本身就带有的库，就叫做 Python 的内置的库，也被称为 Python 的标准库

第三方库：而非 Python 本身自带的库，就是所谓的第三方的库

模块==库，模块，module，也常被叫做库，Lib，Library。

找好了依赖我们就需要使用了，当我们从一个 package 里面调用东西的时候，该__init__.py文件内的代码会被首先执行

py 找不到身边的包的时候，可以将上层包定义为模块或者资源，让相对路径去找

项目结构

本文介绍的 python 项目结构适合于中小型项目，应用非常广泛，初学者应该养成好习惯，一开始就用这种方式来组织自己的代码。

假设新建项目的名称为 myproject，可以在 windows 或 linux终端，创建如下项目结构

└─myproject
    │  .gitignore
    │  LICENSE
    │  readme.md
    │  requirements.txt
    │  setup.py
    │
    ├─myproject
    │      main.py
    │      util.py
    │      __init__.py
    │
    └─test
            test_main.py

if name == ‘main’:

一个python文件通常有两种使用方法，第一是作为脚本直接执行，第二是 import 到其他的 python 脚本中被调用（模块重用）执行。因此 if name == ‘main’: 的作用就是控制这两种情况执行代码的过程，在 if name == ‘main’: 下的代码只有在第一种情况下（即文件作为脚本直接执行）才会被执行，而 import 到其他脚本中是不会被执行的

每个python模块（python文件，也就是此处的 test.py 和 import_test.py）都包含内置的变量 name，当该模块被直接执行的时候，name 等于文件名（包含后缀 .py ）；如果该模块 import 到其他模块中，则该模块的 name 等于模块名称（不包含后缀.py）。

而 “main” 始终指当前执行模块的名称（包含后缀.py）。进而当模块被直接执行时，name == ‘main’ 结果为真

argparse 模块

argparse 是一个 Python 模块：命令行选项、参数和子命令解析器。

argparse 模块可以让人轻松编写用户友好的命令行接口。程序定义它需要的参数，然后 argparse 将弄清如何从 sys.argv 解析出那些参数。 argparse 模块还会自动生成帮助和使用手册，并在用户给程序传入无效参数时报出错误信息

创建解析器

parser = argparse.ArgumentParser(description='Process some integers.')

使用 argparse 的第一步是创建一个 ArgumentParser 对象。

ArgumentParser 对象包含将命令行解析成 Python 数据类型所需的全部信息。你可以在创建的时候向里面输入一些信息

• usage - 描述程序用途的字符串（默认值：从添加到解析器的参数生成）
• description - 在参数帮助文档之前显示的文本（默认值：无）
• add_help - 为解析器添加一个 -h/–help 选项（默认值： True）

添加参数

parser.add_argument('-integers', type=int, default=1)

给一个 ArgumentParser 添加程序参数信息是通过调用 add_argument() 方法完成的

获取数据

args = parser.parse_args()
print(args.integers)

ArgumentParser 通过 parse_args() 方法解析参数。它将检查命令行，把每个参数转换为适当的类型然后调用相应的操作.在脚本中，通常 parse_args() 会被不带参数调用，而 ArgumentParser 将自动从 sys.argv 中确定命令行参数

子命令

ArgumentParser 可以通过 add_subparsers 的方式去创建子命令，用该方法获取的子构造器可以获取更多的子 parser，子 parser 的使用方式和 ArgumentParser 类似

subparsers = parser.add_subparsers(help='sub-command help')
# 添加子命令 add
parser_a = subparsers.add_parser('add', help='add help')
parser_a.add_argument('-x', type=int, help='x value')
parser_a.add_argument('-y', type=int, help='y value')

# 获取 x 并且使用
args = parser.parse_args()
print(args.x)

在向其输入值的时候，需要在前面加上添加的子 parser 名称

-a 1111 -b 123 c2b -x 250

我们可以在创建 subparsers 的时候设定标题，并且以此可以获取用户输入了哪个子 parser

    subparsers = parser.add_subparsers(title="commands", dest="command")
    order_parser = subparsers.add_parser('order')
    args = parser.parse_args()
    if args_info.command == 'order':
    	print("order")

Python 变量类型

python 具有所有动态语言的特性，就是它的类型可以随意转换，值可以瞎几把放

数字

数字数据类型用于存储数值，他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。当你指定一个值时，Number 对象就会被创建：

var1 = 1
var2 = 10

字符串

字符串或串是由数字、字母、下划线组成的一串字符。一般记为 :

s = "a1a2···an"   # n>=0

它是编程语言中表示文本的数据类型。python 的字串列表有2种取值顺序:

• 从左到右索引默认0开始的，最大范围是字符串长度少1
• 从右到左索引默认-1开始的，最大范围是字符串开头

如果你要实现从字符串中获取一段子字符串的话，可以使用 [头下标:尾下标] 来截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。[头下标:尾下标] 获取的子字符串包含头下标的字符，但不包含尾下标的字符

加号（+）是字符串连接运算符，星号（*）是重复操作

str = 'Hello World!'
 
print str           # 输出完整字符串
print str[0]        # 输出字符串中的第一个字符
print str[2:5]      # 输出字符串中第三个至第六个之间的字符串
print str[2:]       # 输出从第三个字符开始的字符串
print str[2:5:2]    # 输出从第二个字符开始、第五个字符结束、步长为二的字符组，即 ['l', 'o']
print str * 2       # 输出字符串两次
print str + "TEST"  # 输出连接的字符串

其他的类数组的数据结构也可以使用上面的操作，我们一般使用中括号来取值，但是也可以用来赋值

判断字符串是否包含特定子串

in 和 not in 在 Python 中是很常用的关键字，我们将它们归类为成员运算符。

使用这两个成员运算符，可以很让我们很直观清晰的判断一个对象是否在另一个对象中，示例如下：

>>> "llo" in "hello, python"
True
>>> "lol" in "hello, python"
False

我们使用 in 和 not in 判断一个子串是否存在于另一个字符中，实际上当你使用 in 和 not in 时，Python 解释器会先去检查该对象是否有__contains__魔法方法

若有就执行它，若没有，Python 就自动会迭代整个序列，只要找到了需要的一项就返回 True

>>> "hello, python".__contains__("llo")
True
>>>
>>> "hello, python".__contains__("lol")
False
>>>

使用字符串对象的 find 方法，如果有找到子串，就可以返回指定子串在字符串中的出现位置，如果没有找到，就返回-1

>>> "hello, python".find("llo") != -1
True
>>> "hello, python".find("lol") != -1
False
>>

字符串对象有一个 index 方法，可以返回指定子串在该字符串中第一次出现的索引，如果没有找到会抛出异常，因此使用时需要注意捕获

"hello, python".index("lio")

我们可以使用 count 的方法来判断。只要判断结果大于 0 就说明子串存在于字符串中

"hello, python".count("lio")

我们还可以使用正则来判断

import re

def is_in(full_str, sub_str):
    if re.findall(sub_str, full_str):
        return True
    else:
        return False

print(is_in("hello, python", "llo"))  # True
print(is_in("hello, python", "lol"))  # False

列表

List（列表） 是 Python 中使用最频繁的数据类型。列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套），列表用 [ ] 标识，是 python 最通用的复合数据类型

list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
 
print list               # 输出完整列表
print list[0]            # 输出列表的第一个元素
print list[1:3]          # 输出第二个至第三个元素 
print list[2:]           # 输出从第三个开始至列表末尾的所有元素
print tinylist * 2       # 输出列表两次
print list + tinylist    # 打印组合的列表

元组

元组不允许更新，用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表

我们可以这么理解，小括号围起来的就是元组

字典

字典是除列表以外 python 之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取

字典用 “{ }” 标识。字典由索引 (key) 和它对应的值 value 组成

dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
 
tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
 
print tinydict['one']      # 输出键为'one' 的值
print tinydict[2]          # 输出键为 2 的值
print tinydict             # 输出完整的字典
print tinydict.get('&_', 1)# 输出键为&_的值，如果没有则返回1
print tinydict.keys()      # 输出所有键
print tinydict.values()    # 输出所有值

判断数据是否在字典中，以下是错误写法

if supplier_level_configuration[c2b_supplier] is not None:
    do something

正确写法如下：

if c2b_supplier in supplier_level_configuration:
	do something

# 在新版被移除了
if supplier_level_configuration.has_key(c2b_supplier):
	do something

getattr、setattr、getitem 、setitem

• getattr 内置使用点号获取实例属性属性如 s.name，自调用 getattr
• setattr 设置类实例属性 如s.name=‘tom’，自调用 setattr
• getitem 使用[]获取实例属性 如s[‘name’]，自调用 getitem
• setitem 使用[]设置实例属性如 s[‘name’] = ‘tom’ ，自调用 setitem

给对象进行容器化可以对类实现这个函数，容器化就是在 dict 后加小括号，通过容器化，使得获取对象的属性有点像访问 dict 或是 list 这样的容器

凡是在类中定义了这个__getitem__ 方法，那么它的实例对象（假定为p），可以像这样

p[key] 取值，当实例对象做p[key] 运算时，会调用类中的方法__getitem__

一般如果想使用索引访问元素时，就可以在类中定义这个方法（getitem(self, key) ）

namedtuple

这个数据结构用于表达类似 POJO 的意思

我们使用字典来存放数据时，他太过抽象，可以存放各种各样的东西进去，而使用元组存放数据，又必须使用下标来获取数据，在表达 List < POJO > 这种需求的时候会特别不爽

这时候可以使用 namedtuple 来表达类的意思

from collections import namedtuple as np
SupplierLevelInfo = np('level_info', 'id, shop_name, level')

namedtuple 的取值方法如下：

arg.supplier_id

# 不能像字典一样取，下面这么写是错误的
arg[supplier_id]
arg['111']

null 与 None

Python 中其实没有 null 这个词，取而代之的是 None 对象，即特殊类型 NoneType，代表空、没有

None 不能理解为0，因为0是有意义的，而 None 是一个特殊的空值

>>> NoneType
NameError: name 'NoneType' is not defined
>>> type(None)
NoneType

Cannot recover from stack overflow

python 的栈溢出问题，如果是由于递归调用导致栈溢出，可通过尾递归优化（python 不支持）

尾递归是指，在函数返回的时候，调用自身本身，并且，return 语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况

为什么递归调用会导致溢出呢？

递归调用是函数调用自己，在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

为什么尾递归不会导致栈溢出？

事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出

遗憾的是，大多数编程语言没有针对尾递归做优化，Python 解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出

我们可以通过 sys.setrecursionlimit() 函数可以更改嵌套层数上限

import sys
sys.setrecursionlimit(10000)

不过还是有可能报错，因为该值修改的上限是 int 的上限，还是个带符号数，因此可能会报 return 一个负数

读取与写入

推荐用 readline（）方法读数据，该方法每次读出一行内容，所以，读取时占用内存小，比较适合大文件，该方法返回一个字符串对象。

f = open("sxl.txt", encoding='utf-8')
line = f.readline()
while line:
    print (line)
    print(type(line))
    line = f.readline()
f.close()

输出结果：
i like the movie
<class 'str'>
i ate an egg
<class 'str'>

使用 open 来写入数据

out_fa = open(work_dir + 'log/product_detail.txt', 'w', encoding='utf-8')
out_fa.writelines(out)