Ubuntu Linux 环境下安装pycharm

https://www.jianshu.com/p/3379892948da 安装虚拟机的教程，在第七下载。虚拟机是盗版，Ubuntu正版，pycharm盗版需要激活。需要注意的是

1. 安装ubuntu时选64位的
2. 如果无法启动，在bios里advanced界面里选择下intel啥的

linux环境下的打开文件和安装文件与windows环境下有所不同，需要用cd 转到相对应的路径，然后用调用命令才可以打开文件

用大佬提供的jetbrains来破解详见zhile.io——————-2022.04.24，这种方法已经不好用了，建议淘宝花点钱买个破解的就行

Python packaging tools not found. 问题

Ubuntu自带的python是2，所以pycharm用的是默认的python，先要把默认的改成python3才可以。然后安装python3-pip，就可以下载库了

python --version   查看python的信息
ls /usr/bin/python* 查看都有哪些python版本
ln -s /usr/bin/python 删除原有的链接，此时再看python版本已经提示无法查看
ln -s /usr/bin/python3 /usr/bin/python  建立新的链接
$ sudo update-alternatives --install /usr/bin/python python /usr/bin/python2.7 1
update-alternatives: 使用 /usr/bin/python2.7 来在自动模式中提供 /usr/bin/python (python) 
$ sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.5 2
update-alternatives: 使用 /usr/bin/python3.5 来在自动模式中提供 /usr/bin/python (python)

终端的命令

exit（） 退出python

control + z 退出

常用的conda命令
更新conda版本: conda update conda
升级anaconda: conda update anaconda
查询conda信息: conda info
查询conda安装的包：conda list
安装包：conda install package_name
安装指定版本的应用：conda install package_name=指定的版本
删除安装包：conda remove package_name
更新安装包：conda update package_name

有时候我们需要在conda中建立多个虚拟环境，用于隔离不同项目所需的不同版本的工具包，以防止版本上的冲突。也可以建立Python2和Python3两个环境，来分别运行不同版本的Python代码。

显示所有的环境：conda env list
查看环境信息：conda info —envs
创建虚拟环境：conda create -n 环境名字 python=指定python版本
复制已有的环境：conda create —name new_env —clone old_env
进入创建的虚拟环境：source activate 环境名字
删除环境：conda env remove -n 环境名字
退出当前环境：source deactivate

工程下面的Venv是虚拟环境

Editor——Font 调字体大小

Settins——->File and Code Template 自动生成一些模板

#-*- codeing = utf-8 -*-
#@Time : ${DATE} ${TIME}

str.split()

u = "www.doiido.com.cn"
print(u[0].split('.')) # 按照.来分割字符串
-----------------------------------------
print(u.split('.'),0) # 分割0次
print(u.split('.'),1) # 分割1次
--------------------------------------

str.join()

连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串

if name == ‘main‘如何正确理解

举一个例子来说明一下，假设我们有一个 const.py 文件，内容如下：

PI = 3.14
def main():
    print "PI:", PI
main()

我们在这个文件里边定义了一些常量，然后又写了一个 main 函数来输出定义的常量，最后运行 main 函数就相当于对定义做一遍人工检查，看看值设置的都对不对。然后我们直接执行该文件(python const.py),输出：

PI: 3.14

现在，我们有一个 area.py 文件，用于计算圆的面积，该文件里边需要用到 const.py 文件中的 PI 变量，那么我们从 const.py 中把 PI 变量导入到 area.py 中：

from const import PI
def calc_round_area(radius):
    return PI * (radius ** 2)
def main():
    print "round area: ", calc_round_area(2)
main()

运行 area.py，输出结果：

PI: 3.14
round area:  12.56

可以看到，const 中的 main 函数也被运行了，实际上我们是不希望它被运行，提供 main 也只是为了对常量定义进行下测试。这时，if __name__ == '__main__' 就派上了用场。把 const.py 改一下：

PI = 3.14

def main():
    print "PI:", PI

if __name__ == "__main__":
    main()

然后再运行 area.py，输出如下：

round area:  12.56

再运行下 const.py，输出如下：

PI: 3.14

这才是我们想要的效果。

if __name__ == '__main__' 就相当于是 Python 模拟的程序入口。Python 本身并没有规定这么写，这只是一种编码习惯。由于模块之间相互引用，不同模块可能都有这样的定义，而入口程序只能有一个。到底哪个入口程序被选中，这取决于 __name__ 的值

避免重复定义

迭代器

iter() 函数用来生成迭代器。

iter(object[, sentinel])

list1=[2,3,4]
for i in iter(list1):
    print(i)

out:2,3,4

args *kwargs

• 　该位置接受任意多个非关键字（non-keyword）参数，在函数中将其转化为元组（1,2,3,4）

*　 该位置接受任意多个关键字（keyword）参数，在函数*位置上转化为词典 [key:value, key:value ]

分为位置参数(position arguments)和关键字参数(key word arguments)

kwargs 可以接受任意数量的关键词参数，以字典的类型。

*args必须在kwargs的前面，帮助文档里这么写主要是一个形式的作用。

d = {'b' : 5,'c' : 7}
def fun(a,b,c):
    print(a,b,c)

fun(1,**d)   # == fun(1,b=5,c=7)

使用**kwargs定义参数时，kwargs将会接收一个positional argument后所有关键词参数的字典。

def fun(a,**kwargs):
    print("a is:",a)
    print(kwargs['b'])
    print(kwargs['c'])
 #调用函数，以字典的方式    
 fun(1,b=5,c=7)

*kwargs总是以variation = 的方式进行调用

使用Sympy求导函数

import sympy
import math

# 求导使用diff方法
x = sympy.Symbol('x')
f1 = 2 * x ** 4 + 3 * x + 6
# 参数是函数与变量
f1_ = sympy.diff(f1, x)
print(f1_)

f2 = sympy.sin(x)
f2_ = sympy.diff(f2, x)
print(f2_)

# 求偏导
y = sympy.Symbol('y')
f3 = 2 * x ** 2 + 3 * y ** 4 + 2 * y
# 对x，y分别求导，即偏导
f3_x = sympy.diff(f3, x)
f3_y = sympy.diff(f3, y)
print(f3_x)
print(f3_y)

zip()函数

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

zip 方法在 Python 2 和 Python 3 中的不同：在 Python 3.x 中为了减少内存，zip() 返回的是一个对象。如需展示列表，需手动 list() 转换。

a = [1,2,3]
b = [4,5,6]
zipped = zip(a,b)

for i in zipped:
    print(i)

Lambda

lambda 函数是一种小的匿名函数。

lambda 函数可接受任意数量的参数，但只能有一个表达式。

相当于略去了函数名，只保留形参，和返回接口。

Fun_name = lambda *args : args[0] , args[1] # 不能超过args的范围

Fun_name(*args)

语法

lambda arguments : expression

x = lambda a : a + 10
print(x(5))

相当于写成函数形式：

def fun(x):
    return x+10

也可以这样用：lambda x:x+10(5)

多个参数的情况

x = lambda a, b : a * b
print(x(5, 6))

作用域

https://zhuanlan.zhihu.com/p/460066453 写的很好
x = 5
def foo(): # 函数被解释器解释，foo指向函数对象，同时解释器会理解x是什么作用域
print(x) # x 在函数解析时就被解释器判定为局部变量
x += 1 # x = x + 1
foo() # 调用时 会报错，UnboundLocalError: local variable ‘x’ referenced before assignment

加入global之后就可以解决这个问题
x = 5
def foo():
global x # 全局变量
x += 1
print(x)
foo()

闭包

def counter():
c = [0]
def inc():
c[0] += 1
return c[0]
return inc
print(counter())
foo = counter()
print(foo(),foo())
c = 100
print(foo())
——————————
def counter():
global count
count = 0
def inc():
global count
count += 1
return count
return inc
foo = counter()
print(foo(), foo())

赋值

d = a
print("id(a):{}".format(id(a)))        # 2558765150984
print("id(d):{}".format(id(d)))        # 2558765150984

赋值语句并没有生成新的容器，跟浅拷贝的区别在于外面的容器也是指向的a的内存地址，并没有生成新的容器，相当于给变量直接起个小名罢了

print()格式化输出

通过说明符输出

%字符：标记转换说明符的开始

• %s 字符串
• %d 整形
• %c 单字符
• %f 浮点数。控制为数 %.2f 保留两位小数
• %x 十六进制

%5d 空出5个字符的宽度
%05d 用0补齐这些空出的宽度
%.3d 表示精确到第三个小数
在末尾加上end = ‘’表示不换行

print("整数：%5d 05.3%d" % (x,y))

通过format方式输出

print(‘{:.0f}’.format(t)) #不带效数四舍五入

固定变量输出

name = 'renyu'
age = 25
print("{} is {} years old".format(name,age))

通过索引值来控制变量

name = 'renyu'
num = 12
print('{0} has {1} apples,{0} feels great'.format(name,num))

将变量名写在format内

name = 'renyu'
num = 12
print('name:{name} has num:{num} apples'.format(name='renyu',num='12'))

可迭代的对象、迭代器和生成器

序列可以迭代的原因：iter函数

当对对象x进行迭代时，会自动调用iter(x)

iter函数是内置函数，有以下作用：

• 检查对象是否实现了iter()方法，如果实现了就调用它，获取一个迭代器
• 如果没有实现_iter**()方法，但是实现了 **getitem_()方法，会创建一个迭代器，尝试从索引0开始获取元素
• 如果尝试失败，会抛出“Type Error”异常，通常会提示“C object is not iterable”

Next()

https://blog.csdn.net/bear_sun/article/details/78479449

读取下一个可迭代对象的数据

多线程处理

线程（Thread）也叫轻量级进程(process)，是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。

读取CSV最后一列label

import csv
def read_label(dir):
    with open(dir, "r") as f:
        #"D:\\dataset\\GTSRB\\GT-final_test.csv"
        reader = csv.reader(f)
        list = [i[0].split(";")[7] for i in reader]
        # print(list)
        list.pop(0)
        # print(list)
        new_numbers = [];
        for n in list:
          new_numbers.append(int(n));
        numbers = new_numbers;
        # print(numbers)

读、写Excel文件

打开xls文件

import xlrd
work_book = xlrd.open

获取工作簿对象属性

# 获取工作簿中sheet表数量
print(work_book.nsheets)
# 获取工作簿中所有sheet表对象
sheets = work_book.sheets()
print(sheets)
# 获取工作簿所有sheet表对象名称
sheets_name = work_book.sheet_names()
print(sheets_name)

按索引、名称获取sheet表对象：

# 按索引获取sheet对象
sheet_1 = work_book.sheet_by_index(0)
print(sheet_1)
sheet_2 = work_book.sheet_by_name('Sheet2')
print(sheet_2)

获取单元格对象及属性：

# 获取sheet表单元格对象，单元格数据类型：单元格值
cell_0 = sheet_1.cell(0,0)
print(cell_0)
# 获取sheet表单元格值
cell_0_value = sheet_1.cell_value(0,0)
print(cell_0_value)

获取sheet表所有行（获得一个生成器）：

# 获得sheet对象所有行对象生成器
rows = sheet_1.get_rows()
print(rows)
for row in rows:
    print(row)

导入工程内的py文件

需要先建立一个init.py文件，把目录做成一个模块，才可以导入

内置函数

内置函数是什么
函数就是以功能为导向，一个函数封装一个功能，那么Python将一些常用的功能(比如len)给我们封装成了一个一个的函数，供我们使用，他们不仅效率高(底层都是用C语言写的)，而且是拿来即用，避免重复早轮子，那么这些函数就称为内置函数，到目前为止python给我们提供的内置函数一共是68个

if 和else写在一行

if alpha > 7:
    beta = 999
elif alpha == 7:
    beta = 99
else:
    beta = 0

可以简化为

beta = 999 if alpha > 7 else 99 if alpha == 7 else 0

arg_parser

我们常常可以把argparse的使用简化成下面四个步骤
1：import argparse
2：parser = argparse.ArgumentParser()
3：parser.add_argument()
4：parser.parse_args()
上面四个步骤解释如下：首先导入该模块；然后创建一个解析对象；然后向该对象中添加你要关注的命令行参数和选项，每一个add_argument方法对应一个你要关注的参数或选项；最后调用parse_args()方法进行解析；解析成功之后即可使用。

map()

map(func, *iterables) —> map object
根据一个函数f将可迭代对象map到另一个变量