python基础知识整理

#Canda环境安装以及包管理

清华镜像下载https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/
命令行启动jupyter notebook或点击快捷图标方式启动
conda list # 查看所在环境的安装的包
conda upgrade --all # 对包进行更新
spyder # 启动anaconda中的IDE
conda install numpy pandas # 在某个环境下能够安装某些Python包
conda install numpy=1.10 # 安装特定版本的包
conda remove < package_name > # 删除包
conda env list # 列出当前机器上创建的虚拟环境
conda create -n env1 python=2.7 # 创建一个名为env1的环境然后在其中安装python2.7
conda create -n env1 numpy # 创建一个名为env1的环境然后在其中安装numpy
source activate env1 # 进入env1虚拟环境，在window上不用加source
source deactivate # 离开环境
conda install -n py27 ipykernel # 在虚拟环境py27下安装ipykernel
python -m ipykernel install --user --name py27 --display-name "python2" # 在py27环境内安装ipykernel并在菜单里命名为python2
conda env remove -n py27 # 移除py27的虚拟环境
conda install jupyter notebook # 在conda环境中安装jupyter notebook
%matplotlib # jupyter notebook中已交互式方式实现matplotlib的绘图
%matplotlib inline # 不跳出，直接内嵌在web中

jupyter notebook常用配置

notebook中的magic开关

为实现一些快捷操作，提升效率。notebook中提供magic开关，能极大的优化使用notebook的体验。
magic开关分为两大类：%line magic & %%cell magic

​

magic开关总览

%quickref# 所有magic命令 
%lsmagic# 打印所有magic命令

%config ZMQInteractiveShell.ast_node_interactivity='all'/'last_expr'
%pprint # 打印所有结果,保证每次执行都输出,默认只输出最后一个内容
%config ZMQInteractiveShell可以查看可选择的输出类型
或者执行这个命令保证多输出
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = 'all'/'last_expr'

 %%整个cell magic
 %%writefile test.py # 将cell中的命令写入文件test.py
 %%timeit代码计时
 %%bash # 在cell内可以执行bash命令
 %%writefile xx.py # 把整个cell中的内容输入到xx.py中,如果新加内容可以%%writefile -a xx.py

 %line magic命令
 %matplotline inline # 在jupyter内打印图片
 %run utils.ipynb # 执行本地的utils.ipynb文件,进行配置

 line magic和cell magic区别就在于line magic只在一行有效,cell magic在多行都有效
 具体参考:https://gispark.readthedocs.io/zh_CN/latest/pystart/jupyter_magics.html

Jupyter notebook扩展

jupyter_contrib_nbextensions
直接安装官网conda命令安装即可
conda install jupyter notebook
conda install -c conda-forge jupyter_contrib_nbextensions 
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple autopep8 
pip安装加速镜像:https://www.cnblogs.com/microman/p/6107879.html
jupyter 使用参考资料:https://zhuanlan.zhihu.com/p/33105153
jupyter extension 参考资料:https://zhuanlan.zhihu.com/p/52890101

jupyter 使用linux命令

!head -n 5 xx.txt # 直接通过jupyter行使linux命令

python

python语言是一种面向对象、动态数据类型的解释型语言
1.运行方式
    解释运行:直接py脚本运行
    交互运行:jupyter输入一个输出一个

2.命名规则:
    常量大写，下划线隔开单词
    类用驼峰命名
     del xx 删除变量xx

3.操作优先级：
    函数调用，寻址，下标
    幂运算
    翻转运算符
    正负号
    * / %
    - + 
4.赋值
    多重赋值:a=b=10相当于a=10,b=10
    多元赋值 a,b,c = 1,2,3
    交换赋值 a,b = b,a # 指针

5.解包(需要拓展 参考:https://zhuanlan.zhihu.com/p/33896402?utm_source=wechat_session&utm_medium=social&s_r=0)
    l1 = [1,2,3,4,5,'6']; a,b,*c,d = l1
    l1=[1,2,3,4];b='sdaad';[*l1,*b]
    b,=[[3,4,5]] # 逗号解包 

6.python进制及基本类型
    bin() 二进制
    oct() 八进制
    hex() 十六进制

    float('inf') 正无穷

基本操作

#行内注释
""" """多行注释
？内省，显示对象的通用信息
？？内省，显示出大部分函数的源代码
help()显示一个对象的帮助文档
%timeit 魔法命令，计算语句的平均执行时间
type（x）查看变量x的数据类型
in(x) 将变量x的数据类型转换为整型
isinstance(x,float)检测变量x是否为浮点型，返回一个布尔型数值

##字符串

s=u" "定义Unicode字符串
s=r" "定义原始字符串，避免字符串中的字符串转义，在正则表达式中经常使用到
len(s)返回s字符串的字数
s.lower()字母全部转为小写
s.upper()字母全部转为大写
s.capitalize()将字符串s中的首个字符转换为大写，其余部分转换为小写
s.replace('k','l')使用字符"l"替换掉s中所有的字符"k",返回结果是cooldata
s.strip()去掉s最前面和最后面的空格
s.split("\t")使用制表符"\t"分割字符串
'%s is No.%d'%(s,1)格式化
'{} is No.{}'.format(s,1)格式化

列表

list()空列表
l[-1]返回列表的最后一个元素
l[1:3]返回列表的第二个和第三个元素
len(l)返回列表长度
l[::-1]将列表进行逆序排列
l.reverse()将列表进行逆序排列
l.insert(1,"b")在指定的索引位置插入'b'
l.append()在列表末尾添加元素
l.extend()等价于"1+L"，将列表L中的元素依次添加到1的末尾
l.remove()删除列表中的某个元素
l.pop()等价于del l[]，删除列表中对应索引位置的元素
" ".join([''c,'o','o','k'])将列表中的各个字符串元素用空格连接起来并转换为字符串，返回结果为cook

条件判断和循环语句

if condition1:
		statement1
elif condition2:
		statement2
else:
		statement3
		
for item in sequence:
		statement
		
while condition:
		statement
		
range(5)产生一个从0到5且间隔为1的整数列表[0，1，2，3，4]
break从最内层for循环或while循环中跳出
continue继续执行下一次循环
pass占位符

enumerate（）and zip（）

for i,item in emumerate(l)在每一次循环时取出索引号和相应的值分别赋给和item
s={item**2 for item in l}集合推导式，对l中的每一个元素取平方得到的新集合
D={key:value for key,value in zip(l,k)}字典推导式，通过zip()函数将两个列表l和k中的元素组成键对并形成字典
enumerate(list/set, start=0) # 遍历元素，start指定从哪个数字作为开始下标
c = list(zip(a,b))
c = set(zip(a,b))
c = dict(zip(a,b))
list(zip(*c)) # 解压

推导式

L=[item**2 for item in l]列表推导式，对l中每一个元素取平方得到新的列表
S={item**2 for item in l}集合推导式，对l中的每一个元素取平方得到新的集合
D={key:value for key,value in zip(l,k)}字典推导式，通过zip()函数将两个列表l和k中的元素组成键值对并形成字典
[i for i in range(30) if 1%2==0] # 取0-29之间偶数
[function(i) for i in range(30) if 1%2==0] # function可以自己定义
[ x**2 if x%2 ==0 else x**3 for x in range(10)] # 两个条件

文件读写

读取文件
f=open(filename,mode)返回一个文件对象f，读文件"mode=r",写文件"mode=w"
f.read(size)返回包含前size个字符的字符串
f.readline()每次读取一行，返回该行字符串
f.readlines()返回包含每个文件内容的列表，列表的元素为文件的每一行内容所构成的字符串
f.close()关闭文件并释放它所占用的系统资源
with open("aa.txt","r") as f:
		content = f.readlines()
在with主体块语句执行完后，自动关闭文件并释放占用的系统资源
import csv
f=open("aa.csv","r")
csvreader = csv.reader(f)
content_list=list(csvreader)
读取csv文件，并把数据存储为一个嵌套列表(列表的元素扔是一个对象)content_list

写入文件
f.write(s)
print(s,file=f)
两种等价的方式，将字符串s写入文件对象f中

函数

def sum(a,b=1)
		return a+b
def sum(*args,**kwargs)不定长参数，*args接收包含多个位置参数的元组，**kwargs接收包含多个关键字参数的字典。
obj.methodname一个方法是一个"属于"对象并被命名为obj.methodname的函数

map()和lambda()

map(func,sequence)将函数依次作用在序列的每个元素上，把结果作为一个新的序列返回。
lambda a,b:a+b匿名函数，正常函数定义的语法糖
lambda [参数列表]:表达式
例如: sum = lambda x,y:x+y # 可以有多个参数,返回只能有一个式子
可以作为一个函数的参数赋给另外一个参数
当然普通函数也可以作为参数传入
a = [{'name':'ss','age':10},{'name':'yy','age':7},{'name':'zz','age':15}] # 将匿名函数作为参数传入第三方函数的参数
a.sort(key=lambda x:x['age']) # sort方法需要传入一个key，这个key可以作为排序依据，lambda可以提取每个元素，并对元素排列
a.sort(key=lambda x:x['age']， reverse=True) # 降序

包模块

包是一个文件夹
模块是不同的python文件
import package.module.func()
import package1.module1, package2.module1 # 多个模块调用
import package1.module1 as p1m1 # 对模块进行重命名使用
from package.module import func1 # 调用某个包某个模块的某个函数
import sys;sys.path # 搜索模块路径，包含当前文件夹
package.module.__file__ # 可以确定当前的模块所在的路径
__init__.py  #在包被加载的时候，会被执行。在一个包下面可以有也可以没有__init__.py
from package import * # 引用包下面所有的模块都加载，自动搜索是不会发生的，
    需要我们在__init__.py下进行定义才可以实现,定义的内容是__all__=["module1","module2"],
    将package下的module1和module2都加载进来
    如果想直接加载某个函数，在__init__.py里面加入from .module1 import func1, __all__=["func1"]
    这样修改完之后，可以直接from package import *，然后直接调用func1即可，不用带package.module
    restart kernel
如果想要直接引用包,如：import package,这样的话，需要一定要有__init__.py，否则会在打印package.__file__的时候报错。
注意import package和from package import *效果相同

Counter

字典的继承类
set dict list tuple 作为key
from collection import Counter # 导入
cnt = Counter()
for i in [1,1,2,2,2,3]:
    cnt[i] += 1
print cnt
如果用key的话会报错先做第一次初始化才行
cnt2 = Counter(alist)  #可以统计每个元素出现的次数（字符串，set,list,）
Counter(cat=4,dogs=8,abc=-1) # 初始化counter次数，或者用dictionary构建
Counter({'cat':4,'dogs':8,'abc':-1})
Counter返回一个字典，如果缺失的话会返回0
del cnt2['xx']
.values()
list(cnt),set(cnt),dict(cnt) # 前两个只返回key
cnt.most_common()[0] # 对出现次数排序
cnt.clear()
cnt1+cnt2 # 对于key相同的value做加法，如果为0则不保留
cnt1-cnt2 # 对于key相同的value做减法
& # 求key相同value的最小值
| # 求key相同value的最大值

random

import random #引入
random.random() # 0-1
random.uniform(1,10) # 包含1，10的浮点数
random.randint(1,10)  # 包含1，10的整数
random.randrange(0,20,3) # 0-20能被3整除的数
random.choice([1,2,3]) # 随机取元素
random.choice("qwdwq") # 随机取元素
random.shuffle([12,3,1,4,2,3]) # 混洗
random.sample([1,2,3,4,5], 3) # 从前面的list中选3个

编码和解码

import chardet
chardet.detect(s)
检测字符串的编码方式

异常处理

try:
		statement
except:
		pass

try:
		statement
except Exception as e:
		print(e)

try:
		statement
except (Exception1,Exception2) as e:
		statement1
else:
		statement2
finally:
		statement3#无论对错都运行
抛出异常
raise Exception('Oops！')
assert statement,e#若继续运行代码、否则抛出e的错误提示信息

正则表达式

import re
raw_s=r'\d{17}[\d|x]|\d{15}'
pattern=re.compile(raw_s)
re.search(pattern,s)
用于匹配身份证号
首先使用原始字符串定义正则表达式；然后编译原始字符为正则表达式Pattern对象；最后对整个字符串s进行模式搜索，如果模式匹配，则返回MatchObject的实例，如果该字符串没有模式匹配，则返回弄none
re.search(r'\d{17}[\d|x]|\d{15}',s)将Pattern编译过程与搜索过程合二为一
re.match(pattern,s)从字符串s的起始位置匹配一个模式，如果匹配不成功返回None
re.findall(pattern,s)返回一个包含所有满足条件的字串列表
re.sub(pattern,repl,s)使用替换字符串repl替换匹配到的字符串
re.split(pattern,s)利用满足匹配模式的字符串将字符串s分隔开，并返回一个列表

1.正则表达式的match与search区别
    https://segmentfault.com/a/1190000006736033

2.贪婪匹配与非贪婪匹配的区别
    https://segmentfault.com/a/1190000002640851
    https://blog.csdn.net/lxcnn/article/details/4756030

3. 练习网站
    https://alf.nu/RegexGolf 一个正则表达式练习网站
    https://regexr.com/ 验证网站

4. 单字符匹配
    . # 匹配出点换行符之外的任意字符
    \. # 匹配单个.字符
    [abd] # 匹配a/b/d单个字符
    \d # 匹配数字, 相当于[1,2,3,4,5,6,7,8,9]
    \D # 所有非字符
    \s # 空白符,空格 tab等等
    \S # 所有非空格
    \w # a-z,A-Z,0-9,_
    \W # 除了 a-z,A-Z,0-9

5. 数量词用来多匹配
    m{2} # 表示匹配两个m
    m{2,4} # 表示匹配2/3/4个m,贪婪匹配
    m* # 0个或者更多个,贪婪匹配
    m+ # 1个或者更多个,贪婪匹配
    m? # 0个或者1个
    ^xx # 文本开头是xx进行匹配
    xxx$ # 对结尾进行匹配
    (re)su(lt) # group

6. python中的正则表达式步骤
    写一个文本pattern
    进行匹配
    对匹配的文本进行后续操作
    例子:
        import re
        pattern = re.compile(r'hello.*\!') # hello后面有若干个字符串直到有!
        match = pattern.match('hello, xxx! how are you?') # 对文本进行匹配
        if match: # 是否匹配
            print match.group() # 如果匹配上了返回相应的匹配到的部分

7. 使用实例
    import re
    re.compile(r"""
    \d+ # 数字部分
    \. # 小数点
    \d # 小数部分
    """, re.X)
    这种模式下可以写注解
    re.compile(r"\d+\.\d") # 与这个模式结果一样

8.一些命令
    match # 一次匹配结果,从头匹配,开头没有就匹配不上了
    search # 所有匹配到的
    findall # search返回第一个匹配的结果,findall会返回所有的结果
    m=re.match()
    m.string # 匹配的字符串
    m.group(1,2) # 匹配1和2处字符串

9. 替换和分割
     split也可以使用正则表达式进行分割
        p = re.compile(r'\d+')
        p.split('adwdwad1dawwd23dwadw') # 字符串复杂分割
    sub # 用来替换
        p = re.compile(r'(\w+) (\w+)')
        p.sub(r'\2 \1', s) # 匹配字符串并且在匹配到的字符串处进行前后颠倒 
    subn # 和sub类似,只不过除了返回替换的远足之外,还返回相应的替换次数,可以p.subn(afunc, s), afunc可以自己定义

日期处理

from datetime import datetimes
format="%Y-%m-%d %H:%M:%S"指定日期格式
date_s=datetime.striptime(s,format)
date_s.year
date_s.month
date_s.now()