python基础学习

---------列表的操作函数---------------

增加
a.append("")
a.insert(3,"")
a.extend(b) 扩展一个列表

删除
a.remove("")
i = a.pop(3) 不指定的话删最后一个
del a[3]
a.clear()

查找位置
a.index("") 查元素的位置
a.count("") 查元素的出现个数
元素 in a 元素是否存在


a.reverse() 翻转
a.sort() 排序
set(a) 去除重复数据 变成集合类型
len(a) 数据个数
enumerate(a,1) 从1开始的索引+数据的元组

深浅拷贝 (只存在于链表中,因为链表指的是地址)
a = b a链表修改,b也跟着变化
a = b.copy() 某链表的值改变,另一个不变,但是某链表里面的链表的值改变,另一个也会变,因为变得是地址.
a = copy.deepcopy(b) 完全不影响, 等于重新建了一个链表 要import copy

-------------end--------------------


----------------字典-------------

增
a.setdefault(键,值) 如果有键,不做变动,如果没有,插入键值对 返回值是键值
查
a[键名]
a.keys() 所有的键
list(a.keys())
a.values() 值
a.items() 键值对
改
a.update(b) 重复的会覆盖
删
pop
del
clear

a=dict.fromkeys(["a","b","c"],"aaa") 数组的时候有奇怪的情况(深浅拷贝)
a.copy() 浅复制 返回相同键值对的新字典
sorted(a)
遍历
for i in dic:
print(i,dic[i])
字符串转字典
b=eval(a)
-------------end--------------------



-----------集合------------------------

不可哈希

s = set(a)
s = frozenset(a)

s.add() 添加一个元素
s.remove() 删除一个元素
s.update() 添加多个元素

a.intersection(b) a & b 交集 相同的部分
a.union(b) a | b 并集 一起
a.difference(b) a - b 差集 补集
a.symmetric_difference(b) a ^ b 对称差集 单独在A或者单独在B
a.issuperset(b) a>b 是否为b的父集
a.issubset(b) a<b 是否为b的子集


---------字符串操作---------------

'hello'*2
'hello'[2:] = 'llo'
'lo' in 'hello' True

c=''.join([a,b]) join函数 通过前面的字符串把字符串拼接起来

''.count('s') 统计个数
''.capitalize() 首字母大写
''.center(30,'-') 居中,用后面的字符填充
''.ljust(30,'-') 字符左对齐,用后面的字符填充
''.rjust(30,'-') 字符右对齐,用后面的字符填充
''.encode()
''.decode()
''.endswith('') 是否以字符结尾
''.startswith('') 是否以字符开头
''.expandtabs(tabsize=10)
''.find('') 找第一个字符的索引值 找不到返回-1
''.index('') 找第一个字符的索引值 找不到报错
''.format() 格式化输出 '111{name}'.format(name=222) '111222'
''.format_map() 格式化输出 字典 '111{name} is {age}'.format({'name':1,'age':2}) '1111 is 2'

''.lower() 大写变小写
''.upper() 小写变大写
''.swapcase() 大小写反转
''.title() 每个单次首字母大写

''.strip() 去掉换行符和左右空格 ''.lstrip() ''.rstrip()
''.replace('','',x) 替换所有参数 或者x个
''.rfind() 从右边找,返回索引值
''.split(' ',2) 以空格分割成列表 分隔几次
''.rsplit(' ',2) 以空格分割成列表 从右开始分隔几次





isalnum 是否是数字+字母+汉字 (带符号返回False)
isalpha 字母
isdecimal 十进制
isdigit 整数
isidentifier 非法字符
islower 小写字母
isupper 大写字母
isspace 是否全是空格
istitle 是否标题(首字母大写)

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

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

b:bytes
python3.x里默认的str是(py2.x里的)unicode, bytes是(py2.x)的str, b”“前缀代表的就是bytes
python2.x里, b前缀没什么具体意义， 只是为了兼容python3.x的这种写法


-----------------end---------------------


----------------文件操作----------------

f = open('', 'r', encoding='utf-8')
f.close()

with open('','r') as f:
..
..

a = f.readline()
a = f.readlines()

for i in f
print(i)

f.tell() 指针位置
f.seek(0) 调整指针位置


-------------------end---------------


调用时间模块

import time

time_format = '%Y-%m-%d %X'
time_current = time.strftime(time_format)

# print(time.clock()) #返回处理器时间,3.3开始已废弃 , 改成了time.process_time()测量处理器运算时间,不包括sleep时间,不稳定,mac上测不出来
# print(time.altzone) #返回与utc时间的时间差,以秒计算
# print(time.asctime()) #返回时间格式"Fri Aug 19 11:14:16 2016",
# print(time.localtime()) #返回本地时间 的struct time对象格式
# print(time.gmtime(time.time()-800000)) #返回utc时间的struc时间对象格式

# print(time.asctime(time.localtime())) #返回时间格式"Fri Aug 19 11:14:16 2016",
#print(time.ctime()) #返回Fri Aug 19 12:38:29 2016 格式, 同上



# 日期字符串 转成 时间戳
# string_2_struct = time.strptime("2016/05/22","%Y/%m/%d") #将 日期字符串 转成 struct时间对象格式
# print(string_2_struct)
# #
# struct_2_stamp = time.mktime(string_2_struct) #将struct时间对象转成时间戳
# print(struct_2_stamp)



#将时间戳转为字符串格式
# print(time.gmtime(time.time()-86640)) #将utc时间戳转换成struct_time格式
# print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) #将utc struct_time格式转成指定的字符串格式





#时间加减
import datetime

# print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925
#print(datetime.date.fromtimestamp(time.time()) ) # 时间戳直接转成日期格式 2016-08-19
# print(datetime.datetime.now() )
# print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天
# print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天
# print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时
# print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分



global
nonlocal

ret = filter(func, str) 过滤器, 只返回执行结果为true的,其他直接过滤 返回一个迭代器
ret = map(func, str) 处理器,每一个字符去处理, 返回迭代器

from functools import reduce
reduce(func,range()) 后面的值每两个进行func运算然后叠加


-------------装饰器----------------

@fun #f=fun(f)
def f

生成器的两种创建方式
a=(x for x in range(100))
def foo()
yield 1
s = yield 2
foo()

next(a)
a.send('') 下一次进去的时候传给yield前的参数

迭代器
isinstance() 判断是否为迭代器
生成器包含于迭代器
for循环执行的3件事:1.用iter()创建迭代器对象2.调用next()方法3.处理stopiteration



-----------------os---------------------
os.getpid()
os.getppid()


os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd
os.curdir 返回当前目录: ('.')
os.pardir 获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2') 可生成多层递归目录
os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove() 删除一个文件
os.rename("oldname","newname") 重命名文件/目录
os.stat('path/filename') 获取文件/目录信息
os.sep 输出操作系统特定的路径分隔符，win下为"\",Linux下为"/"
os.linesep 输出当前平台使用的行终止符，win下为" ",Linux下为" "
os.pathsep 输出用于分割文件路径的字符串
os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command") 运行shell命令，直接显示
os.environ 获取系统环境变量
os.path.abspath(path) 返回path规范化的绝对路径
os.path.split(path) 将path分割成目录和文件名二元组返回
os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path) 返回path最后的文件名。如何path以／或结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path) 如果path是绝对路径，返回True
os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间

---------------end---------------


运行shell命令
import subprocess

a = subprocess.Popen('...', shell=True, stdout=subprocess.PIPE)


----------------正则表达式-------------

re.match 从头开始匹配
re.search 匹配包含 加上括号就可以吧括号里的内容作为一个列表
re.findall 把所有匹配到的字符放到以列表中的元素返回
re.finditer 结果是一个迭代器
re.split 以匹配到的字符当做列表分隔符
re.sub 匹配字符并替换
re.compile 将一个正则表达式编译成对象 可以直接调用对象.方法进行正则表达式匹配

'.' 默认匹配除 之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
'^' 匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a"," abc eee",flags=re.MULTILINE)
'$' 匹配字符结尾，或e.search("foo$","bfoo sdfsf",flags=re.MULTILINE).group()也可以
'*' 匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac") 结果为['abb', 'ab', 'a']
'.*'
'+' 匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
'?' 匹配前一个字符1次或0次
'{m}' 匹配前一个字符m次
'{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']
'|' 匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'
'(...)' 分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c
'[]' 匹配列表里的内容,取消元字符的特殊功能,除了 ^取反 -


'A' 只从字符开头匹配，re.search("Aabc","alexabc") 是匹配不到的
'' 匹配字符结尾，同$
'd' 匹配数字0-9
'D' 匹配非数字
'w' 匹配[A-Za-z0-9]
'W' 匹配非[A-Za-z0-9]
's' 匹配空白字符、 、 、 f v, re.search("s+","ab c1 3").group() 结果 ' '

'' 匹配一个特殊边界,单体和空格或者任何特殊字符 re.findall(r'I','I am II) 结果前一个I 不是正则表达式的内容

'(?P<name>...)'
分组匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city")
结果{'province': '3714', 'city': '81', 'birthday': '1993'}



-------------json-------------

json.dumps() 把字典等类型转成字符串
json.loads()

f1=open('','w')
json.dump(dic,f)
f2=open('','r')
json.load(f)

pickle.dumps() 函数和类也可以





创建一个“队列”对象
import queue
q = queue.Queue(maxsize = 10)
q = queue.LifoQueue(maxsize = 10)
queue.Queue类即是一个队列的同步实现。队列长度可为无限或者有限。
可通过Queue的构造函数的可选参数maxsize来设定队列长度。如果maxsize小于1就表示队列长度无限。

将一个值放入队列中
q.put(10)
调用队列对象的put()方法在队尾插入一个项目。
put()有两个参数，第一个item为必需的，为插入项目的值；
第二个block为可选参数，默认为1。
如果队列当前为空且block为1，put()方法就使调用线程暂停,直到空出一个数据单元。
如果block为0，put方法将引发Full异常。

将一个值从队列中取出
q.get()
调用队列对象的get()方法从队头删除并返回一个项目。
可选参数为block，默认为True。如果队列为空且block为True，
get()就使调用线程暂停，直至有项目可用。如果队列为空且block为False，队列将引发Empty异常。

Python Queue模块有三种队列及构造函数:
1、Python Queue模块的FIFO队列先进先出。 class queue.Queue(maxsize)
2、LIFO类似于堆，即先进后出。 class queue.LifoQueue(maxsize)
3、还有一种是优先级队列级别越低越先出来。 class queue.PriorityQueue(maxsize)

此包中的常用方法(q = queue.Queue()):
q.qsize() 返回队列的大小
q.empty() 如果队列为空，返回True,反之False
q.full() 如果队列满了，返回True,反之False
q.full 与 maxsize 大小对应
q.get([block[, timeout]]) 获取队列，timeout等待时间
q.get_nowait() 相当q.get(False)
非阻塞
q.put(item) 写入队列，timeout等待时间
q.put_nowait(item) 相当q.put(item, False)
q.task_done() 在完成一项工作之后，q.task_done() 函数向任务已经完成的队列发送一个信号
q.join() 实际上意味着等到队列为空，再执行别的操作

---------常用库---------------
jieba 中文库
jieba.lcut(string) 列表

wordcloud 词云

Numpy N维数据表示和运算
Matplotlib 二维数据可视化
PIL 图像处理
SKlearn 机器学习和数据挖掘
Pyinstaller
flask 轻量级web开发框架
werobot 微信机器人
sympy 数学符号计量工具
pandas 高效数据分析和计算
networkx 复杂网络结构和图结构的建模和分析
pyqt5 基于qt的专业级GUI开发
pyopenGL 多平台OpenGL开发接口
PyPDF2 PDF文件内容提取和处理
docopt 命令行解析