python

Python基础

一、基础语法

pip管理包：

查找Python包命令 :sys.path

下载命令：pip  install  包名字

创建虚拟环境：Python  -m  venv  tutorial-env
激活：tutorial-env\Scripts\activate.bat

上传到真实的pypi：

python -m pip install setuptools wheel twine
创建包文件：setup.py
           LICENSE
           README.md
python -m pip install --user --upgrade setuptools wheel
python setup.py sdist bdist_wheel
python -m pip install --user --upgrade twine
twine upload dist/*

注释：#

多行注释：“”“ ”“” ‘’‘ ’‘’

引入：import math import random import sys

输入输出：print() input()

用法：1、传入数据   print(123,456)
      2、传入表达式  print(123,1+2)
      3、混合型   
      4、支持多个参数
      5、格式化输出    %s字符串   %d整型    %f浮点型  %0.3f 小数点位数
      print("我的名字是%s尹晓杰，我的年龄是%d22，我有很多钱%f￥"%("尹晓杰"，22，200.000))
    6、end可选参数
    print（"123",end=""）
    print("456",end="")
    123456

input("请输入您的名字")  参数为提示信息，会阻塞程序
input(arg)  arg提示，   返回类型是str

注意：1、变量不需要声明，直接赋值使用

​ 2、没有自增自减 a+=1 a-=1

​ 3、变量名由数字、字母、下划线构成，数字不能开头，支持中文

​ 4、不能使用特殊字符$ # @ *等

​ 5、不能使用关键字和保留字

​ 6、严格区分大小写

​ 7、变量交换 a,b=10,20 a,b=b,a

数据类型：

数字型(number)  整型int()  浮点型float()  复数
浮点型控制小数点的位数
%0.2f  
round（float，位数）

字符串型(str)
列表（数组）(list)
元组 (tuple) 不可变的列表
字典型(对象，json)    (dict)
集合 (set)
布尔类型 (bool)
None

数字型：

进制转换(将十进制转化为其他进制)
bin(num)将十进制转化为二进制
oct(num)将十进制转化为八进制
hex(num)将十进制转化为十六进制

字符串型：

定义：''   ""   """  """  '''  '''

转义字符：\t空格   \\    \'      \"     \n    print("af \daf")
字符串前缀：r 后面字符串是普通字符串
           b 后面的字符串bytes
           u 后面字符串是unicode

字符编码：

ASCII   GBK   gb-2312    unicode   utf-8

切片：

[start:end:step] 开始：结束：步长
str="山西太原小店区开通大厦"
print（str[::1]）
print(str[0:5:1])

列表：

定义：存储一系列相关数据的集合
注意事项：1、列表可以存储任意数据类型
         2、列表是可变数据
         3、列表可以使用切片
         4、列表可以定义一个元素的列表，空列表，多维列表
arr1=[1,2,3]
arr2=[]
arr3=[1]
arr4=[[1,2],[4,55],[12,4]]
print(arr1,arr2,arr3,arr4)
列表访问：list[index]
列表操作：
list.append() 在末尾插入
list.insert(index,item) 将对象插入到列表中 
list.pop()删除  默认最后一个
del list[index]删除
list.clear()清空
list.copy()浅拷贝 arr5=arr4.copys  print(arr5)
list.deepcopy()深拷贝
list.count(item)计数
list.extend(list)扩展  arr1.extend(arr4)  print(arr1)
list.index(item)返回下标
list.remove(item)删除元素
list.reverse()倒序
list.sort()排序

推导式：

[表达式 for 元素 in list序列 if条件]

arr1=[1,2,3,4,5]
attr2[item*2  for item in arr1 if item<2]

生成式：

(表达式  for 元素  in list  序列  if条件)

遍历：

arr=[1,2,3,4,5]
for item in arr:
    print(item)
for item in arr:
    print(arr.index(item),item)
 输出:   0   1
		1   2
        2   3
        3   4
        4   5
for i，item in enumerate(arr):
    print(i,item)
dict.fromkeys(['英语','数学','语文'],98)
for k in dict1.keys():
    print(k)
for v in dict1.values():
    print(v)
for k,v in dict1.items():
    print(k,v)
 遍历推导   
{k:v for k,v in dict.items() if条件}
{k  for k in dict.keys() if条件}
dict1=dict.fromkeys(['英语','数学','语文'],98)
dict2={"xb_"+k:v-8 for k,v in dict.items()}
print(dict2)  

元组：

不可变的列表    地址不变
tuple1=(1，2，3，4，5)
tuple2=([1,2],[3,4])
tuple3=([1，2，3，4，5])
tuple4=()
tuple5=(1,)
tuple6=1,2,3,4
内建方法：
tuple.index() 获取元素在元组中的索引值,对于重复的元素,默认获取从左起第一个元素的索引值
tuple.count() 统计元组中某元素的个数

字典型：

创建字典：
dict1={'name':'小白'}
dict2=dict(name='小白',sex='男')
dict3=dict([('name','sex'),('小白','男')])
dict4=dict(zip(['name','sex'],['小白'，'男']))
快速创建值一样的字典：
dict.fromkeys(list,data)
dict.fromkeys(['英语','数学','语文'],98)
字典的访问方式：
dict[key访问的内容]
常用内建函数：
dict.clear()清空字典
dict.copy()浅拷贝
dict.fromkeys()快速给key赋相同的值
dict.get(key,[default])  获得key的值，如果不存在返回None  dict.get('age',"没有"或者"18")给一个默认值
dict.items()返回键值的序列
dict.keys()返回键序列
dict.values()返回值序列
dict.pop(key) 删除key对应的item
del dict[key]  删除
dict.setdefault(key,default)设置默认值
     dict2=dict(name='小白',sex='男')
     dict2=setdefault('age','18')
     print(dict2)
dict.update()更新    传入可选参数或其他字典进行更新
     dict2=dict(name='小白',sex='男')
     dict2.update(age=18)
     print(dict2)

集合型：元素是唯一的

创建集合：
set1=set("13245")
set2=set("山西优逸客")
set3=set([1,2,3,4,5])
去重：
set4=set([1,1,2,2,])
list1=list(set4)
print(list1)
内建方法：
set.add()添加元素
set.clear()清空集合
set.copy()浅拷贝
set.pop()删除任意一位元素
set.remove()移除
set.update()更新：
    set5={1234}
    set5.update({6789})
    print(set5)
集合的操作：
&交集
|并集
-补集
^对称集
>前包含后
<后包含前
>=
<=

布尔型：

true  false

二、运算符：

算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符、成员运算符、身份运算符

算术运算符：

包含：
第一组+ - * /
第二组% ** //
1、+ *除了加、乘以外还可以操作字符串、列表、元组
2、/结果都为浮点型
print(1/1)
   1.0
**幂运算
//地板除,向下取整
print(10//3)
    3

str1="abc"
print(str1*3)
abcabcabc
print([1,2,3]+[4,5,6])
(1,2,3,4,5,6)

赋值运算符：

+=  -=  *=   /=  %=  //=  **=    =

关系运算符：

>  >=  <  <=   !=
==(JavaScript动态类型、弱类型的语言，所以有===，,python动态类型，强类型语言)

逻辑运算符：

and 与
or  或
not 非

位与运算：

&按位与  有0为0 全1为1
|按位或  有1为1 全0为0
^按位异或 同0异1
>>右移
<<左移

成员运算符：

in  如果在指定的序列中找到值返回 True，否则返回 False
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 
print('name' in {'name','xb'})

身份运算符：

is
is not
arr1=[1,2,3]
arr2=arr1
print(arr1 is arr2)
区分is和==: is 用于判断两个变量引用对象是否为同一个   == 用于判断引用变量的值是否相等
    相等不一定是同一个

三、流程控制：

分支语句

单路分支：
	if 条件：
       pass
双路分支：
	if 条件：
    	pass
    else:
        pass    
a,b=10,20
if a>b:
    print("a>b")
 else:
    print("a<b")
    
表达式1 if 条件  else 表达式2

多路分支：
	if 条件：
    	pass
    elif 条件：
    	pass
    else:
        pass  
if a>b:
    print("a>b")
elif a==b:
    print("a==b")
else:
    print("a<b")

循环语句：

while 条件：
	pass
for i in 序列：
	pass

for i in range()  开始，结束，步进

干预循环语句：

break 终止循环
continue 终止本次循环
else 循环完成时执行，break语句之后不执行
for i in range(10):
    for j in range(10):
        print(i,j)
    else:
        print("第%s行结束"%i)

四、函数：

函数的语法：

def	函数名[参数]
	"""函数的简介
	
	函数的详细信息
	"""
    函数体
	[return]

    注释
(调用注释)函数名.__doc__
    参数
1、必选参数
2、默认参数
3、可变参数
4、关键字参数

必选参数：

必须要传参
def fn(a,b):
    print("a:",a)
    print("b:",b)
fn(10,20)  #a=10,b=20
fn(b=10,a=20) #b=10,a=20
fn()错误
fn(10)错误

默认参数：

缺省参数
def fn(a,b,c=10):
    print("a:",a)
    print("b:",b)
    print("c:",c)
fn(10,20)	#10   20  10
fn(10,20，30)	#10  20  30
fn(c=30,b=10,a=20)
fn(c=30,20,10)错误
参数可以是变量，但是只能挂载一次
num=10
def fn(a,b,c=num):
    print("a:",a) #10
    print("b:",b) #20
    print("c:",c) #10
num=20
fn(10,20)

可变参数：

接收任意个数的参数，内部是元组形式
def fn(*args):
	print(args)
fn(1,2,3,4)

def fn(a,b,c=44,*args):
    print("a:",a) #10
    print("b:",b) #20
    print("c:",c) #30
	print(args)   #40
fn(10,20,30,40)
可变参数实现数据共享
mylist=[]
def fn(a,arr=[])：
	arr.append(a)
    print(arr)
fn(10) #[10]
fn(20) #[10,20]
fn(30) #[10,20,30]

关键字参数：

以键值的形式传参，内容是字典形式，没有顺序
def fn(**kwargs):
    print(kwargs)
fn(name="小白",sex="男")  #字典形式 {'name': '小白', 'sex': '男'}

可变参数、关键字参数的数据解压：

列表和字典数据形式->数据压缩
列表解压
def fn(*args):
    print(args)
list2=[1,2,3]
fn(*list2)   #(1,2,3)
字典解压
xh={'name':'xh','sex':'女'}
def fn(**kwargs):
    print(kwargs)
fn(**xh)
输出：{'name': 'xh', 'sex': '女'}

传参顺序：

必选参数、默认参数、可变参数、关键字参数

返回值：

return 
作用：返回并终止函数
注意:1、可以写多个return语句，最终只执行一个
	 2、不能再return语句之后书写代码
     3、return只能返回一个数据，如果想返回多个数据必须list\tuple\dict
def fn():
    return 1,2,3
a,b,c=fn()
print(a,b,c)

匿名函数：

作用：作为参数进行传递，简化程序

语法：
lambda a[,b]: 函数体
参数可以有多个，之间","分割
函数体只有一个表达式，并且自动return
调用方式：
1、作为参数直接传递
2、用变量进行保存(fn=lambda a,b,c:a+b+c)
3、自调用 print((lambda a,b,c:a+b+c)(1,2,3))
fn=lambda a,b,c: a+b+c
print(fn(1,2,3))
#类似于
def fn(a,b,c):
    return a+b+c

高阶函数：

把一个函数名作为参数传递到另外一个函数中(实参高阶函数)

把一个函数名作为返回值返回(返回值高阶函数)

常用的高阶函数：
1、map(fn,iter) 
   map(fn,iter1,iter2)
list1=[1,2,3,4,5]
list2=[1,2,3,4,5]
print(list(map(lambda x,y:x+y,list1,list2)))  #[2, 4, 6, 8, 10]
print(list(map(lambda x:x**2,list1)))   #[1, 4, 9, 16, 25]
2、filter(fn,iter) 筛选
list1=[1,2,3,4,5]
print(list(filter(lambda x:x%2==0,list1)))  #2，4
3、reduce(fn,iter)
from functools import reduce
list1=[1,2,3,4,5]
print(reduce(lambda x,y:x+y,list1))
累乘：
from functools import reduce
list1=[1,2,3,4,5]
def fn(x,y):
    print("x:",x,end=" ")
    print("y:",y,end=" ")
    print("x*y",x*y)
    return x*y
reduce(fn,list1) 
输出：x: 1 y: 2 x*y 2
	  x: 2 y: 3 x*y 6
      x: 6 y: 4 x*y 24
      x: 24 y: 5 x*y 120

局部环境、全局环境

>>函数内称为局部环境，局部环境内的变量就是局部变量
>>整个.py文件中为全局变量，全局变量在整个.py文件中都访问变量
>>通过dir()方法可以查看全局环境中的变量以及局部环境中的变量
1、global全局变量声明，不能声明的同时赋值
name='小白'
def fn():
   global name
   name='小红'
   print(name)  #小红
fn()
print(name)  #小红
2、nonlocal非局部非全局声明
name='小白'
def fn():
   name='小红'
   def fn1():
      nonlocal name
      name='小爱' 
      print(name)  #小爱
   fn1()
   print(name) #小爱
fn()
print(name) #小白

闭包函数

当俩个函数发生嵌套关系时，内层函数调用了外层函数的变量，当在外部调用内层函数时，此刻就发生了闭包

def fn():
    num=2
    return lambda x:x**num
fn1=fn()
print(fn1(10))

递归函数

自己调用自己

本质，相当于循环

必须有终止

装饰器：

定义：给一个函数增加新的功能
应用场景：当一个应用上线，如果想要增加他的功能，就希望不要过多的改变源代码
条件：
1、不能改变源代码
2、不能改变源代码调用方式
3、满足1和2的基础上增加新功能
import time 
def fn():
    time.sleep(2)
    print("程序正在运行...")
def timer(fn): #定义装饰器
    def newfn():
        start=time.time()
        fn()
        end = time.time()
        print("运行总时间为%s"%(end-start))
    return newfn
fn=timer(fn)
fn()
4、公式：
<函数+闭包+高阶函数+语法糖=装饰器>
5、装饰器传参
import time
def timer(a,b):#定义装饰器
    def timer1(fn):
        def newfn():
            start=time.time()
            fn()
            end = time.time()
            print("程序已崩溃%s"%(end-start))
            print(a,b)
        return newfn
    return timer1
@timer(10,20)
def fn():
    num=0
    for i in range(10000):
        num+=i
    print(num)
fn()
6、柯里化
def fn(a):
    def fn1(b):
        def fn2(c):
            print(a+b+c)
        return fn2
    return fn1
fn(10)(20)(30) 

五、文件操作

1、核心函数：

open(file,mode)
参数：
file 文件的地址
code 打开文件的模式
encoding 编码方式
errors 错误  ignore 忽略
返回值：文件对象 

2、打开模式

r 只读
w 只写 清空并写入   如果文件不存在会新建文件
a 追加 指针在文件尾，文件内容后追加内容，如果文件不存在会新建文件
r+ 读写
w+ 读写
a+ 读写 
rb  wb ab rb+  wb+  ab+   操作二进制文件

3、文件操作的步骤

打开文件 操作 关闭文件

4、文件读操作

fileobj.read([num])  读取num个字符，如果没有num默认读取文件全部
fileobj.readline([num]) 读取某一行的num个字符
fileobj.readlines() 读取文件全部

5、文件的关闭

fileobj.close()

6、文件写操作

fileobj.write(con) 文件写入
fileobj.writelines(con) 写入列表全部内容

7、文件指针

fileobj.seek(offset,0)  设置指针相对于文件头的偏移量
fileobj.tell()

8、文件操作规范

try:
    f = open("doem.txt", 'r')
    con=f.read()
fianlly:
    if f:
    f.close()
 with open("demo.txt","r") as f:
    f.read()

9、当需要保存数据到文件中时，数据格式转化

import   json
json.dumps() 把json数据转化为str
json.loads() 把符合json格式的字符串数据转化为json格式
eval(str) 将符合python语句的字符串解析成python语句

10、持久化存储pickle

import  pickle
pickle.dump(data,fileobj) 可以将任意类型进行存储到file文件
pickle.load(fileobj) 加载file文件中的数据

11、csv

csv是一种数据保存方式，常用在表格和数据库中
1、四个常用对象：
csv.reader()
csv.DictReader()
csv.write()
csv.DictWrite()
2、写入的方法：
fw.writerow()  写入单行
fw.writerows() 写入多行
fw.writeheader() 写入表头

Python进阶：

一、面向对象

1、类的基本语法：

class 类名 ：    不能在全部环境下使用
	def __init__(self)
    	self.属性名=属性值
    def 方法名(self):
        print("class方法")
实例化：
a=类名（）

定义：
1、类属性、实例属性
类属性调用：
通过类和实例进行调用，类属性可以共享数据
实例属性调用：
只能通过实例调用
实例属性aa和类属性aa相同时，实例调用优先考虑实例属性aa
2、静态方法、类方法、实例方法
静态方法：只能通过类进行调用，不能调用类的任何属性
类方法：通过类和实例进行调用，可以调用类的属性
实例方法：可以调用静态方法、类方法、实例方法
3、继承：
class A(B,C):
    method...
#继承
class A:
    def say(self):
        print('A类')
class B:
    def tell(self):
        print('B类')
class C(A,B):  #派生  A，B基类
    pass
print(dir(C))
调用方法时采用深度有优先方式搜索
4、派生标准类

迭代器：

class Reverse:
    def __init__(self,data):
        self.data=data
        self.index=len(data)
    def __iter__(self):
        return self
    def __next__(self):
        if self.index<=0:
            raise StopIteration
        self.index -= 1
        return self.data[self.index]
myiter=Reverse([1,2,3,4])
# print(next(myiter))

for i in myiter:
    print(i)

生成器：

特殊的迭代器，只能使用一次，使用的时候才创建
创建方法：函数     生成器表达式（）
def fun():
    for i in range(10):
        yield i   #yield 相当于return   记录当前状态
# 方式一
aa=fun()
for i in aa:
    print(i)
for i in aa:
    print(i)
# 方式二
aa=(i*i for i in range(10))
for i in aa:
    print(i)
for i in aa:
    print(i)

模块与包

1、模块：每一个.py文件
如何导入模块：import 模块/路径
from 路径/包/模块/import  模块/命名
from 路径/包/模块/import  模块1   模块2
from 路径/包/模块/import *
为什么要有模块：分开开发
2、包：存放相关模块的文件夹，包内要有__init__.py
为什么要有包：

import 可以在任何位置调用，但要注意作用域
3、as
用来更换命名的
 import mymodules.a2 as a2

包和模块常用的方法：

1、绝对路径和相对路径的使用（在组模块中用）
	. 当前   ..上一级
2、__all__用法
__all__用来指定
3、拆分模块
from a1 import say1,say2
4、可以通过字符串导入模块
import importlib
random=immportlib.import_module("random")
5、__main__.py 运行目录  
6、sys.path 可以查看模块的搜索路径

截取内容中的图片

import re
res=re.findall(r'<img alt="" src=".*?">',con)
str=",".join(res)

datetime

#时间戳
time.time()
时间元组
date=time.localtime(time.time())
格式化时间
string=time.strftime("%Y",date) 大小写有区别
time.strftime("%Y-%m-%d %H:%M:%S")当前时间
#time方法：
time.sleep()
time.time()
time.localtime() #将时间转为时间元组
time.strftime() #将时间元组变为字符串
time.mktime(t) #将时间元组转化为时间戳
#datetime模块
1、datetime常用类
datetime.date #年月日
datetime.time #具体时间
datetime.datetime  date和time #结合
datetime.timedelate 时间间隔
2、datetime.date 常用方法：
datetime.date(2018,12,1) 创建时间
datetime.date.today() #获取当前时间
datetime.date.fromtimestamp(time.time())
实例：.strftime() 格式化时间
实例：.timetuple() 转为时间元组
实例：replace(year=2015) 替换
3、datetime.time常用方法
datetime.time() 创建时间
实例：.strftime() 格式化时间 
实例：.replace() 替换
4、datetime.datetime常用方法
datetime.datetime.today() 当前时间
datetime.datetime.now() 当前时间
datetime.datetime.fromtimestamp(timestamp) #将时间戳转化为datetime
datetime.datetime(2018,11,12,12,0,3)
5、datetime.timedelta类
datetime.timedelta() 延时，一个时间段，可以用来加减