python基础复习

基本数据类型

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()  # 没有返回 None
        dic['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 copy
 copy.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 123
    print('我是第二段')
    yield 456
    print('第三段')
    yield 789
g=func()  #生成器
print(g.__next__())

//send()的理解
def generator():
    while True:
        receive=yield 1
        print('上一个的值'+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)

字典推导式

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*n
        lambda 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 re
 findall :匹配所有每一项都是列表中的一个元素
    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) # alekxkHfjkfjakHfajk12
 subn   返回一个元组,返回第二个元素是替换的次数
	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下cd

os.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.load

import 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  只能接受一个布尔值

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