基本数据类型

int     整数
str     字符串
bool    布尔值 bool   True   False
list    列表 []
tuple   元组 ()
dict    字典  {key:value}
set     集合  不重复
type()   查看基本数据类型

切片

切片默认是从左往右切,但是步长为- 可以改变方向
步长
s[0:4:-1]   //- 表示反方向
s[0:6:2]   //每两个切一个,切前面的那个

占位

"我是{name},{age},{sex}".format(name="zhangsan",age="12",sex="wangwu")
len()  长度

迭代

for c  in  arr:pinrt(c)

列表的增删改查

arr.append("")
insert(1,"lisi")  # 指定位置增加
arr.extend(['a','b','v'])  # 迭代添加 在后面添加
pop(1)
remove("李四")
del list[1:3]
clear
[1::2]
count("李四")  查询的次数
sort()  //   sort(reverse=True)  降序
reverse()
len() 长度

元组

(,)   只读  (增删改都不可以)
元组是可迭代对象
查(可以)
arr[2]
但是元组的二层是列表是可变的
tu=(1,'s','how are you',[])
tu[-1].append('x')

range 可迭代对象

for i in range(n):print(i)  # 0到n-1   跟切片一个道理

字典 {}

dic={'name':'张三','age':'lisi'}
增
dic['sex']='xxx'
dic.setdefault(key,value)#如果没有这个key就增加,有就不改变原来的
删pop   dic.pop('name')del   del dic['name']clear  dic.clear()popitem()    dic.popitem()   随机删除 返回一个 元组
改dic['name']='xxx'dic.update(dic1)   更新
查for循环    dic = {'name': 'zhangsan', 'age': 12}for i in dic:print(i)   # for循环默认拿到字典的键get()dic.get()  # 没有返回 Nonedic['names']  没有这个键的时候查询会报错keys()  拿到的是高仿列表 values() 也是拿到的高仿列表items()  拿到高仿列表的元组dic = {'name': 'zhangsan', 'age': 12}for key,value in dic.items():print(key,value)fromkeys (返回的是一个新的字典)dict1=dict.formkeys([1,2,3],['one','two','three'])#  {1: ['one', 'two', 'three'], 2: ['one', 'two', 'three'], 3: ['one', 'two', 'three']}dict1 = dict.fromkeys([1, 2, 3], 'xxx')# {1: 'xxx', 2: 'xxx', 3: 'xxx'}结构
a,b=1,2
a,b=b,a
[a,b]=[b,a]

is ==

is  比较内存地址  id()
==   比较值小数据池   数字  -5到256 字符串不能包含特别符号 + - * / @等  (注意pycharm所有的字符串一般都是一样的内存地址)单个字符*20以内的内存地址保持一致
python3  使用的是 unicode
pycharm 存储的时候默认是utf-8编码 encode
解码  decode

set 集合

特点:  无序  不重复   可hash(不可变)
arr={'name','age','sex'}
append  增
arr.add('lisi')
froaenset()  冻结的集合
copy()  浅拷贝  [:]   深拷贝import copycopy.deepcopy(list1)

文件操作

操作函数open(文件路径,mode="?",encoding="字符集")  //utf-8
模式: r   w   a   r+  a+   rb     wb      ab例子f = open('./91.js', mode='r', encoding="UTF-8")s = f.read()print(s)f.close()readline()  读一行
f.flush() 缓冲
f.write()  写
f.close()  关闭如果mode里面有b 就不能写 encoding
# r+  比较常用  默认的先读后写
# seek(偏移量,位置) 光标移动
seek(0)  移动到开头
seek(0,2)  末尾with open('./91.js', mode='r+', encoding="utf-8") as f1:for line in f1:print(line)文件修改
with open('./aaa.txt', mode='r', encoding="utf-8") as f1, \open('./91_1.js', mode='w', encoding='utf-8') as f2:for line in f1:print(line)if line.strip() == 'console.log(a[1]);':f2.write('+')f2.write(line)
os.remove('aaa.txt')
os.rename('91_1.js', 'aaa.txt')

函数

def xx():return 'x'
xx()
顺序位置参数> *args,默认值参数,**kwargs(关键字参数)def fun(a, *args, c='哈哈哈', **kwargs):fun(1, 2, 3, 4, 5, c='lisi', d='wangwu', f='zhangsi')# 1 (2, 3, 4, 5) lisi {'d': 'wangwu', 'f': 'zhangsi'}
globals()  全局作用域
locals() 查看当前作用域的内容global  在局部访问全局中的内容
nonlocal  寻找外层函数中离他最近的那个变量def func(*args):print(args)
func(*[1,2,3,4,5],*"我是一个字符串")
# (1, 2, 3, 4, 5, '我', '是', '一', '个', '字', '符', '串')
max([1,2,3,3,4])
min([12,3,4,4,5])__iter__()   获取迭代器
__next__()s = 'abcdedg'it = s.__iter__() # 获取迭代器while 1:try:print(it.__next__())except StopIteration:  #处理错误break
迭代器的特点*  只能向前,惰性机制,省内存枚举 enumerate()
for (i,item) in enumerate(arr):print(i, item)
字典的操作
dic = {'name': 'zhangsan', 'age': 12}
for k,v in dic.items():print(k, v)

生成器

def func():print('我是一个段')yield 123print('我是第二段')yield 456print('第三段')yield 789
g=func()  #生成器
print(g.__next__())//send()的理解
def generator():while True:receive=yield 1print('上一个的值'+str(receive))
g=generator()
next(g)
g.send(111)
g.send(333)
把 yield 1视为一个表达式
要next() 执行一次后才能使用send(),send()接受上一个 yield 1的结果

推导式

str=[1,2,3,4,4,5]
for i in range(len(str)):str[i]

推导式的语言

[ 结果 for循环 判断 ]

lst =[i for i in range(100) if i%2==1]
print(lst)

字典推导式

{k:v for循环 条件}

dic={'name':'zhangsan','age':'lisi','sex':"xxx"}
d={v:k for k,v in dic.items()}
print(d)

集合推导式

s={el for el in list}

生成器表达式(没有元组推导式因为不能迭代)

tu=(i for i in range(10))
tu.__next__()
tu.__next__()

内置函数

iter()   #内部封装的就是__iter__
next()   #__next__
int()
float()
min()
max()
sum()
lst[slice(1, 3, 2)]repr   原样输出
format(3,'b')  转换成2进制
r"nihao\n\tksks"  原样输出
zip()  水桶效应有短板a=1,2
print(a)# 这是元组lambda  匿名函数语法:  lambda  参数: 返回值__name__  查看函数的名字a=lambda n:n*nlambda x,y:(x,y)  # 如果不加括号就是一个元组print(a(8))map     映射函数

sorted 排序

arr = [1, 2, 3, 6, 673, 3, 2, 2, 3, 3]
s = sorted(arr)
print(s)  # 升序sorted(iterable, key=None, reverse=False)  默认升序
s=[('a', 1), ('b', 2), ('c', 6), ('d', 4), ('e', 3)]
sorted(s,key=lambda x:x[0])

filter 过滤

s = [1, 2, 3, 4, 4, 5, 6, 7]
filter(function,lterable)  # 第一个参数是一个函数,第二个参数是一个可迭代对象
p=filter(lambda x:x>3,s)
print(list(p))

map 映射函数

s = [1, 2, 3, 4, 4, 5, 6, 7]
p=map(lambda x:x*x,s) # 第一个参数是一个函数,第二个参数是一个可迭代对象
print(list(p))

re模块

模块就是跟我们提供的功能
re模块:在python中使用正则表达式正则的用途
# 从大段的文字中找到符合规则的内容 * 爬虫:从网页的字符串获取你想要的数据* 日志分析
# 判断某个字符串是否完全符合规则* 表单验证
> 只和字符串打交道字符组: []  * [0-9]  [a-z]   [A-Z]元字符* \   转移字符* \w  单词   [a-zA-Z0-9_]* \d  数字    [0-9]* \s  匹配所有的空白符  \n  \t(制表符)* \b  单词的边界* ^   配置字符串的开始* $   配置字符串的结束* .   匹配除了换行符之外的所有字符* []  只要[出现]在中括号内的* [^] 只要[不出现]在中括号的* a|b 符合a规则的或b规则的(如果a规则是b规则的一部分,且a规则要苛刻一些,就把a规则写在前面)(将更复杂的更长的写在前面)* ()  分组
量词* {n}  出现n次* {n,}  至少出现n次* {n,m} 出现n到m次* ?     出现0到1次* +     出现1到多次* *     出现0到多次正则表达式的匹配特点:贪婪匹配(回溯算法)
简单的说就是在允许的范围内去最长的结果
非贪婪匹配/惰性匹配: 在量词后面加上?> .*x  贪婪  匹配到最后一个x停止(回溯算法)> .*?x 惰性  匹配任意非换行字符任意长度,只要匹配到第一个x就停止了
原样输出r'\nssss\t'
书: <<正则指引>>

查找

 import refindall :匹配所有每一项都是列表中的一个元素ret=re.findall('\d+','zheshi 123fkafkk23f四大皆空233')print(ret) # ['123', '23', '233']  search : 只匹配从左到右的第一个(常用)# 如果没有匹配到会返回None,但是使用group会报错ret=re.search('\d+','sksj123按照花费fdkk123')if ret:print(ret.group()) # 通过ret.group() 获取真正的结果match :从头到尾匹配,相当于 search中的正则表达式加上一个^split切割ret=re.split('\d+','alex12fwjek12fjka44')print(ret) # ['alex', 'fwjek', 'fjka', '']sub   正则,旧的,新的,替换次数(默认一次)ret=re.sub('\d+','H','alekxk823fjkfjak12fajk12',2)print(ret) # alekxkHfjkfjakHfajk12subn   返回一个元组,返回第二个元素是替换的次数ret=re.subn('\d+','H','alekxk823fjkfjak12fajk12')print(ret) # ('alekxkHfjkfjakHfajkH', 3)

re模块的进阶(时间\空间)

compile  节省使用正则表达式解决问题的时间
# 在多次使用的过程中,不会多次编译
# 编译一个正则表达式,用这个结果去search, match,findall,finditer能够节省空间ret=re.compile('\d+') # 已经编译了res=ret.findall('adkfj1212fjkajf1212djfk12')print(res) # 返回的结果跟之前一样但是节省了时间finditer  节省你使用正则表达式解决问题的空间/内存
# 返回一个迭代器,所有的结果都在这个迭代器中,需要循环+group的新式取值ret = re.finditer('\d+', 'alex122fdkajfk122fkjak1221')for i in ret:print(i.group())

分组

s = '<a>wah32aha</a>'
ret = re.search('<(\w+)>(\w+)</(\w+)>', s)
print(ret.group()) #所有的结果
print(ret.group(1)) # 数字参数代表的是取对应分组中的内容   # a
print(ret.group(2)) # wah32aha
print(ret.group(3)) # a# 为了findall顺利取到分组中的内容,()可以优先显示分组中的内容
ret=re.findall('>(\w+)<',s)
# 取消分组优先(?:正则表达式)
ret=re.findall('\d+(?:\.\d+)?','1.234*4.3')
print(ret) # ['1.234', '4.3']

random 模块

import random取随机小数
random.random()  #取0到1之间的小数
random.uniform(1,2) # 取1-2之间的小数取随机整数(彩票,抽奖)
random.randint(1,2)  #[1,2]
random.rangrange(1,2) #[1,2)从列表中随机抽取值(抽奖)
l=['a','b','v',(1,2)]
print(random.choice(l))
# 第二个参数是接收随机的个数
print(random.sample(l, 2))打乱一个列表的顺序,在原列表的基础上直接进行修改,节省空间
random.shuffle(l)强转成字符
chr(81) # Q

time时间模块

time.time()  时间戳(1970/01/01/00:00:00)
print(time.strftime('%Y-%m-%d %H:%M:%S'))   当前格式化时间
#%Y-%m-%d %H:%M:%S 记忆下来
print(time.localtime())  # 结构化时间

# 时间戳->结构化时间->格式化时间
print(time.strftime('%y-%m-%d %H:%M:%S', time.localtime(time.time())))
# 格式化时间->结构化时间->时间戳
print(time.mktime(time.strptime('2018-08-08', '%Y-%m-%d')))

sys模块

sys 是和python解释器打交道的
在命令行执行python文件,而不是在pycharm中执行
sys.argv   文件名:整个文件路径不能有空格,不支持中文
sys.argv=['python文件的路径','参数1','参数2']
好处是不需要在程序中以input的形式输入
sys.path  里面放的是文件夹的绝对路径
sys.modules

os模块

资料

os模块是与操作系统交互的一个接口
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.system("bash command")  运行shell命令，直接显示
os.popen("bash command).read()  运行shell命令，获取执行结果
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cdos.path
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所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小

序列化

dumps  loads:在内存中做数据转换* dumps  数据类型  转成 字符串  序列化* loads  字符串  转成 数据类型  反序列化
dump  load在文件中做数据转换* dump  序列化* loads 反序列化import json
### 向文件中记录字典
dic = {'key': 'value', 'key2': 'value2'}
ret=json.dumps(dic) #序列化
with open('json_file','a') as f:f.write(ret)### 从文件中读取字典
with open('json_file','r') as f:str_dic=f.read()
dic=json.loads(str_dic)
print(dic.keys())### 写文件
import json
dic = {'key': 'value', 'key2': 'value2'}with open('json_file1','a') as f:json.dump(dic,f)### 读文件
with open('json_file1','r') as f:dic=json.load(f)print(dic.keys())###格式化 方便自己看
json.dumps(data,indent=4)

pickle

支持在python中几乎所有的数据类型
只能在python中使用
在做文件操作的时候,需要用rb wb的模式打开文件
可以多次dump 和多次load
import pickle
pickle.dumps
pickle.loads
pickle.dump
pickle.loadimport pickle
dic={"key": "value", "key2": "value2"}### 写
with open('json_file2','wb') as f:pickle.dump(dic,f)### 读
with open('json_file2','rb') as f:print(pickle.load(f))

异常处理

try:执行的代码
except Exception as e:print(e)# 可以写在文件里面
####
try:执行的代码
except:报错的信息
else: #当try中代码不发生异常的时候,走else分支,# 也就是说发送成功了,进行一些处理xxx###
finally:  # 无论如果都会被执行# 即使return  也会先执行 fianlly 中的代码
# finally 用来回收一些操作系统的资源:数据库连接,打开文件的句柄,网络连接网络异常的几种方式
try...except
try...except...else
try...findlly
try...except...finally
try...except...else...finally主动抛出异常 :是给其他开发者用的
raise  ValueError断言  (看源码)
assert 1==2  只能接受一个布尔值

异常处理的忠告,在最外层的异常处理应该在所有的开发结束之后再放异常