python教程（仅用于自己学习） 来源：w3school

python 语法

-缩进
用于切分不同的代码块

if 1+1:
 print("2")
if 3>1:
    print("3比1大")

-变量
存放数据值的容器
字符串变量可以用单引号或双引号声明

-变量名称
必须以字母或者下划线开头，不能以数字开头
只能包含字母数字下划线
区分大小写

-多个变量赋值

x,y,z="lisa","rose","jennie"
print(x)
print(y)
print(z)

-输出变量
print(数值）
print("text"+字符串)

x=1
y=2
z=x+y
print(z)

x="wyb"
print("The beauty is " + x)

-全局变量
在函数外部创建的变量，可以供函数外部和内部的使用

x = "awesome"
def myfunc():
  print("Python is " + x)
myfunc()

在函数内部创建全局变量使用global

def myfunc():
 global x
 x = "awesome"
 myfunc()
print("Python is " + x)

-数据类型
type()获取数据类型

--数字类型
int,float,complex
int()、float() 和 complex() 可以转换数据类型
random()表示随机数
format()可以组合数字与字符,将他们放在占位符{}里,自动邮件中使用到

x=1005
txt="My birthday is {}"
print(txt.format(x))

--布尔类型
True,False

--数组类型
列表（List），有序可更改的集合，允许重复；列表用方括号[ ]编写
元组（Tuple），有序不可更改的集合，允许重复;元组用括号()编写
集合（Set），无序无索引的集合，无重复;集合用花括号{}编写
词典（Dictionary），无序可变有索引的集合，无重复；字典用花括号{}编写，拥有键和值

列表(List)与numpy 中数组(Array)的区别：
list中的元素的数据类型可不一样；array中的元素的数据类型必须一样；
list中的元素不可进行四则运算；array可以；
lsit 比array具有更多的存储空间；
两者均可通过索引查找元素

• List

x=["xz","wyb","bxg","zz","bb"]
print(x)
#len()查看列表的长度
print(len(x))

#负索引从最后一个开始
print(x[-1])

#通过起始点（包含）到终点（不包含）来指定索引范围
print(x[0:3])

#替换值
x[0]="zz"
print(x)

#append() 将项目添加至列表的末尾
x.append("yb")
print(x)

#insert(指定索引处，"项目"）
x.insert(3,"szd")
print(x)

#remove(指定项目)，pop(指定索引)，del 删除指定的项目
x.remove("zz")
print(x)
x.pop(0)
print(x)
del x[-1]
print(x)

#clear()清空列表
x.clear()
print(x)

#copy()复制列表
x=["bjyx","xz","wyb","szd"]
y=x.copy()
print(y)

#list()复制列表
z=list(x)
print(z)

#合并列表，直接+ 或者将其中一个列表的项目追加到另一个项目中或者extend()将列表元素添加至末尾
a=x+y
print(a)

x=["xz","wyb","zz","bb"]
y=["bjyx","zsww","lsfy","szd"]
for a in y:
 x.append(a)
print(x)

x.extend(y)
print(x)

#list()构造新列表，双括号
bjyx=list(("xz","wyb","zz","bb"))
print(bjyx)

#sort()排序
x=list(("5","1","8","3","3"))
x.sort()
print(x)

• 元组（tuple）

a=("wyb","xz","zz","bb","szd")
print(a)
#返回元组第1个项目
print(a[0])
#更改元组，将元组转换成列表再进行更改
b=list(a)
b[0]="yb"
a=tuple(b)
print(a)
#遍历元组a的项目
for x in a:
print(x)
#创建一个有项目的元组,如果只有一个项目，需要加逗号,
b=("b","j","y","x","s","z","d")
c=("bjyxszd",)
#元组无法更改，只能完全删除元组用 del
del c
#合并元组用+
c=a+b
print(c)
#构建新的元组，tuple(()) 两个括号
d=tuple(("b","j","y","x"))
print(d)

• 集合（set）

a={"s","z","d"}
print(a)
#add()添加项目
a.add("bjyx")
print(a)
#update添加多项
a.update(["wyb","xz","zz"])
print(a)
#remove()删除项目
a.remove("zz")
print(a)
a.clear()
del a
#union()合并两个集合
#set(())创建新的集合，双括号
a=set(("xz","wyb","zz","bb"))
c=a.union(b)
print(c)

• 字典（dictionary）

a={"name":"wyb"
   ,"gender":"male"
   ,"age":24
   ,"job":"actor"
  }
#通过引用键名来查找项目或者使用get()方法
x=a["name"]
print(x)

y=a.get("job")
print(y)
#通过键名来更改值
a["job"]="singer"
print(a)
#使用values()返回字典里的值
for x in a.values():
 print(x)
#使用items()返回字典里的键和值
for y in a.items():
 print(y)
#通过增加新的索引键来添加新项目
a["works"]="EOEO"
print(a)
#pop(),del删除指定键名的项
a.pop("works")
print(a)
del a["age"]
print(a)
#popitem()删除最后插入的项目
a.popitem()
print(a)
#clear()清空字典里的项目
a.clear()
print(a)
#copy()复制字典
a=dict(name="xz",gender="male",age=29)
print(a)

-循环

• if

a=1
b=3
if a > b:
    print("a>b")
elif a<b:
    print("a<b")
else:
    print("a=b")

• while

#预先设置索引变量i=1,递增i,当i=3时，循环停止
i=1
while i<7:
    print(i)
    if i==3:
        break
    i += 1
#递增i,当i=3时，停止当前迭代，继续下一个
i = 1
while i < 7:
    i += 1
    if i == 3:
        continue
    print(i)

• for
  用于迭代序列（元组，列表，字典，集合等），不需要预先设置索引变量

x=["b","j","y","x","s","z","d"]
for y in x:
    print(y)

#当遇到j时，停止迭代，返回b j 
for y in x:
    print(y)
    if y=="j":
        break

#与上不同的是先停止迭代再打印，此时只返回j
for y in x:
    if y=="j":
        break
    print(y)

#continue,遇到j时，停止当前迭代继续下一个迭代
for y in x:
    if y=="j":
        continue
    print(y)

#range()函数，默认从0开始，递增1，并以指定的数字结束
#返回0-9的值
for x in range(10):
    print(x)
#range(起始值，结束值，增量)
for x in range(3,15,3):
    print(x)

#嵌套循环，外循环没迭代一次，内循环将执行一次
x=["b","j","y","x"]
y=["x","z","d"]
for a in x:
    for b in y:
        print(a,b)

-函数
将参数传递到函数中，函数将参数作为结果返回
用def来定义函数
参数在函数括号里指定，可以添加任何参数，用逗号隔开

函数与方法的区别：

• 函数分类：
  内置函数
  自定义函数
  匿名函数
  递归函数
• 方法分类：
  普通方法
  私有方法
  属性方法
  特殊方法
  类方法
  静态方法
• 作用域
  函数：函数作用后，通过赋值等方法修改变量的值不会被保留
  方法：用方法对变量的修改的值会保留
• 调用方式
  函数：函数名()
  方法：对象.方法名()

def my_func(a,b,c):
    print(a+b*c)
my_func(1,2,3)

#以什么类型发送到函数，到达函数内仍是该类型
def my_func(wyb):
    for x in wyb:
        print(x)
wyb=["male","24","actor"]
my_func(wyb)

#return返回函数值
def my_func(a,b,c):
   return a+b*c
my_func(1,2,3)

#函数递归
#求一元二次方程的解
def my_func(a,b,c):
    if a==0:
        if b==0:
            if c==0:
                return("任意解")
            else:
                return("无解")
        else:
            result=-c/b
            return result
    elif a!=0:
        if b**2-4*a*c>=0:
            result1=(-b+(b**2-4*a*c)**0.5)/(2*a)
            result2=(-b-(b**2-4*a*c)**0.5)/(2*a)
            return(result1,result2)
        else:
            return("无解")
    print(result)
my_func(1,3,1)

-类与对象
类（Class）:一个模板，通过类可以创建无数个具体实例
对象（object）：类不能直接使用，通过类创建出的实例（又称对象）才能使用
属性：类中的所有变量为属性
方法：类中的所有函数；包括实例方法（该类的每个实例都可以调用的方法，只有实例才能调用对象方法，有一个额外的参数self），类方法(将类本身作为对象进行操作的方法，类和实例都可以调用），静态方法（存在与类中的普通函数，不会对实例进行任何操作）

#内置的 __init__() 函数，使用该函数将值赋值给对象属性，每次使用类创建新对象时，都会自动调用 __init__() 函数
#self参数，是对类的当前实例的引用，用于访问该类的变量，必须是任意函数的首个参数，可任意命名
class bjyx:
    def __init__(self,name,age):
        self.name=name
        self.age=age        
b1=bjyx("wyb",24)
b2=bjyx("xz",30)
print(b1.name,b2.name)
#对象方法，在类bjyx中创建方法，在b1对象中执行它
class bjyx:
    def __init__(self,name,age):
        self.name=name
        self.age=age 
    def myfunc(self):
     print("bjyx is "+ self.name)
b1=bjyx("wyb",24)
b2=bjyx("xz",30)
b1.myfunc()+b2.myfunc()

-继承
允许继承另一个类的所有属性和方法

class bjyx:
    def __init__(self,name,age):
        self.name=name
        self.age=age 
    def myfunc(self):
     print("bjyx is "+ self.name)
class bx(bjyx):
 pass   #不向该类中添加任何其他属性与方法
x1=bx("bb",24)
x2=bx("zz",30)
x1.myfunc()+x2.myfunc()

#如果在子类中添加一个与父类中的函数同名的方法，则将覆盖父方法的继承
class bjyx:
    def __init__(self,name,age):
        self.name=name
        self.age=age 
    def myfunc(self):
     print("bjyx is "+ self.name)
class bx(bjyx):
    def __init__(self,name,age,job):
      super().__init__(name, age)  #super函数自动继承父类的方法和属性
      self.job=job
    
    def welcome(self):
     print("welcome",self.name,self.job,"to weibozhiye")
x1=bx("bb",24,"actor")
x2=bx("zz",30,"actor")
x1.myfunc()+x2.myfunc()

-模块

#创建模块，将所需代码保存在calculation.py文件
def cal_func(a,b,c):
    if a==0:
        if b==0:
            if c==0:
                return("任意解")
            else:
                return("无解")
        else:
            result=-c/b
            return result
    elif a!=0:
        if b**2-4*a*c>=0:
            result1=(-b+(b**2-4*a*c)**0.5)/(2*a)
            result2=(-b-(b**2-4*a*c)**0.5)/(2*a)
            return(result1,result2)
        else:
            return("无解")
    print(result)


#通过import来使用模块module_name.function_name
import calculation as cal
cal.cal_func(1,2,1)

-日期

#使用datetime模块的datetime()类创建日期
#datetime()类需要三个参数来创建日期：年、月、日
import datetime as dt
x=dt.datetime(2021,1,1)
print(x)

#[strftime()方法](https://www.runoob.com/python/att-time-strftime.html)，将日期对象格式化为可读字符串的方法
import datetime as dt
x=dt.datetime(2021,2,5)
print(x.strftime("%Y-%m"))

-json
用于存储和交换数据的语法，在数据库存储字段信息时使用，需要解析

#json.loads()方法，解析json字符串，结果是Python字典dictionary
import json
x='{"name":"wyb","age":24,"job":"dancer"}'
y=json.loads(x)
print(y["name"])

#json.dumps()方法，将Python对象转换为json字符串
import json
x={"name":"wyb","age":24,"job":"dancer"}
y=json.dumps(x)
print(y)

-RegEx
正则表达式是形成搜索模式的字符序列，可用于检查字符串是否包含指定的搜索模式
re模块中的函数：
findall:返回包含所有匹配项的列表
search:如果字符串中的任意位置存在匹配，则返回Match对象
split:返回在每次匹配时 拆分字符串的列表
sub：用字符串替换一个或多个匹配项

#findall()函数
#查找所有"a"
import re
txt="China is a great country"
x=re.findall("a",txt)
print(x)

#search()函数
#检索字符串以查看它是否以"china"开头并以"country"结尾
import re
txt="China is a great country"
x=re.search("^China.*country$",txt)
if (x):
    print("match")
else:
    print("no match")

#split()函数
#在每个字符处进行拆分
import re
txt="wyb and xz are great actors"
x=re.split("\s",txt)
print(x)
#指定maxsplit参数来控制出现次数
import re
txt="wyb and xz are great actors"
x=re.split("\s",txt,3)
print(x)

#sub函数
#用数字10050805替换每个空白字符
import re
txt="wyb and xz are great actors"
x=re.sub("\s","10050805",txt)
print(x)
#通过指定count参数来控制替换次数
import re
txt="wyb and xz are great actors"
x=re.sub("\s","10050805",txt,2)
print(x)

python文件处理

open()函数有两个参数：文件名和模式

• 四种打开文件的不同方法：
  "r":读取-默认值
  "a":追加，在原文件末尾追加
  "w":写入，会覆盖原文件
  "x":创建

#open()函数返回文件对象，此对象有一个read()方法用于读取文件的内容,close()关闭文件
f = open("demofile.txt")
print(f.read())
f.close()

#在文件中追加内容
x=open("E:/miki/coupang/bjyx.txt","a")
x.write("bjyx")
x=open("E:/miki/coupang/bjyx.txt","r")
print(x.read())

#创建新文件
y=open("D:/miki/coupang/wyb.txt","x")

#remove()删除文件
#rmdir()删除文件夹
import os
os.remove("E:/miki/coupang/wyb.txt")

Python NumPy

NumPy是用于处理数组的Python库
NumPy旨在提供一个比传统Python列表快50倍的数组对象，NumPy数组存储在内存中的一个连续位置，因此进程可以非常有效地访问和操纵他们

import numpy as np
arr=np.array([1,2,3,4,5])
print(arr)
print(type(arr))

NumPy中的数组对象称为ndarray,将列表、元组或任何类似数组的对象传递给array()方法,然后它被转换为ndarray

-数组中的维
数组深度（嵌套数组（将数组作为元素的数组））的一个级别

#ndim属性，返回一个整数，表示数组的维数
import numpy as np
a=np.array(1)
b=np.array([1,2,3,4,5])
c=np.array([[1,2,3],[4,5,6]])
d=np.array([[[1,2,3],[4,5,6]],[[1,2,3],[4,5,6]]])
print(a.ndim)
print(b.ndim)
print(c.ndim)
print(d.ndim)

数组维数

#创建数组，用ndmin参数定义维数
import numpy as np
arr=np.array([1,2,3,4],ndmin=5)
print(arr)
print('number of dimensions:',arr.ndim)

创建数组

import numpy as np
arr=np.array([1,2,3,4])
print(arr[0])

#访问二维数组中的元素，可以使用逗号分隔的整数表示元素的维数和索引
#访问第一维中的第二个元素
import numpy as np
arr=np.array([[1,2,3,4,5],[6,7,8,9,10]])
print('2nd element on 1st dim:',arr[0,1])

-裁切数组

#[start：end：step]
import numpy as np
arr=np.array([1,2,3,4,5])
print(arr[0:3:2])

-NumPy数组数据类型

#dtype属性返回数组的数据类型
import numpy as np
arr=np.array([1,2,3,4,5,6])
print(arr.dtype)

#用数据类型“字符串”创建数组
import numpy as np
arr=np.array([1,2,3,4,5,6],dtype='S')
print(arr.dtype)

-NumPy数组形状

#shape属性返回一个元组，每个索引具有相应元素的数量
#（2,4）表示该数组为二维，每维有4个元素
import numpy as np
arr=np.array([[1,2,3,4,5,6],[2,4,3,4,5,6]])
print(arr.shape)

-NumPy数组排序

#sort() 函数排序
import numpy as np
arr=np.array([[1,2,3,4,5,6],[2,4,3,4,5,6]])
print(np.sort(arr))

-NumPy数组过滤

#使用布尔索引列表来进行过滤，索引处的值为True则过滤到数组中，False则排除
import numpy as np
arr=np.array([1,2,3,4,56,25,61,23])
#新建一个空列表
filter_arr=[]
#遍历arr中的每个元素
for element in arr:
    #如果元素可以被2整除，则将值设置为True,否则设置为False
    if element%2==0:
        filter_arr.append(True)
    else:
        filter_arr.append(False)
newarr=arr[filter_arr]
print(newarr)
print(filter_arr)

-NumPy随机数
NumPy中提供了random模块来处理随机数

#randint()随机整数，rand()随机浮点数
from numpy import random
x=random.rand(3,5)
print(x)

生成随机数

-机器学习
数据的分布

#从均匀分布中随机采样numpy.random.uniform(low,high,size)
import numpy as np 
import matplotlib.pyplot as plt
x=np.random.uniform(0.0,1.0,500)
plt.hist(x,5)
plt.show()

#从正态分布中随机采样numpy.random.normal(mean,std,size)
import numpy as np 
import matplotlib.pyplot as plt
x=np.random.normal(0.0,1.0,500000)
plt.hist(x,100)
plt.show()

#散点图pyplot.scatter(x,y),需要两个长度相同的数组，一个数组用于 x 轴的值，另一个数组用于 y 轴的值
import matplotlib.pyplot as plt
x=np.random.normal(1,0.5,10000)
y=np.random.normal(2,0.5,10000)
plt.scatter(x,y)
plt.show()

正态分布

散点图

-机器学习-线性回归
线性回归用于找变量与变量之间的关系，预测未来的趋势

import matplotlib.pyplot as plt
from scipy import stats
x=[4,5,12,4,5,8,9,15,18,48,52,90]
y=[45,40,45,67,81,49,63,33,56,40,89,101]
#slope斜率，intercept截距,r相关性，p是否显著,std_err标准差
#r-square在0-1之间，0表示不相关，1表示完全相关；p值看x与y的线性关系是否显著，<0.05则显著相关
slope,intercept,r,p,std_err=stats.linregress(x,y)
def myfunc(x):
    return slope*x+intercept
#map(function,iterable,...)函数，对函数function对给定的序列做映射;第一个参数function被每个元素调用，并返回每次function返回值的列表
mymodel=list(map(myfunc,x))
plt.scatter(x,y)
plt.plot(x,mymodel)
plt.show()
slope,intercept,r,p,std_err

线性回归

#导入pandas模块读取csv文件,并返回一个DataFrame对象
import pandas as pd
#导入sklearn模块使用 LinearRegression() 方法创建一个线性回归对象
from sklearn import linear_model
df=pd.read_csv('E:/miki/cars.csv')
#将独立值列表命名为大写X,将相关值列表命名为小写y
X=df[['Weight','Volume']]
y=df['CO2']
regr=linear_model.LinearRegression()
#fit()方法，将独立值和从属值作为参数，并用描述这种关系的数据填充回归对象
regr.fit(x,y)

predictedCO2=regr.predict([[2300,1300]])
print(predictedCO2)

-缩放
特征缩放：数据拥有不同的值，不同的度量，需要将数据缩放成可以进行比较的值
标准化：z = (x - u) / s 其中 z 是新值，x 是原始值，u 是平均值，s 是标准差。

#StandardScaler()方法，返回带有转换数据集方法的scaler对象
import pandas as pd
from sklearn import linear_model
from sklearn.preprocessing import StandardScaler
scale=StandardScaler()
df=pd.read_csv('E:/miki/cars.csv')
x=df[['Weight','Volume']]
scaledX=scale.fit_transform(x)
print(scaledX)

fit(),transform(),fit_transform()
fit(x,y) 训练集的固有属性
transform(x) 标准化
fit_transform()是两者的结合

-评估模型
训练/测试：衡量一个模型准确度，将数据分为两组，80%作为训练集，20%作为测试集

#查看数据集
import numpy as np
import matplotlib.pyplot as plt
np.random.seed(2)
x=np.random.normal(3,1,100)
y=np.random.normal(150,40,100)/x
plt.scatter(x,y)
plt.scatter(x,y)
plt.show()

#拆分训练/测试集
#数组裁切 [start:end:step]
train_x=x[:80]
train_y=y[:80]

test_x=x[80:]
test_y=y[80:]
#显示测试集/训练集
plt.scatter(train_x,train_y)
plt.show()
plt.scatter(test_x,test_y)

#拟合数据集
#绘制多项式回归线
import numpy
import matplotlib.pyplot as plt
numpy.random.seed(2)
x=numpy.random.normal(3,1,100)
y=numpy.random.normal(150,40,100)/x
train_x=x[:80]
train_y=y[:80]
test_x=x[80:]
test_y=y[80:]
#自由度是4，生成多项式对象
#poly1d(系数向量)
mymodel=numpy.poly1d(numpy.polyfit(train_x,train_y,4))
myline=numpy.linspace(0,6,100)

plt.scatter(train_x,train_y)
plt.plot(myline,mymodel(myline))
plt.show()

#计算训练集的拟合度R2
import numpy
from sklearn.metrics import r2_score
#seed(2)表示从第二堆种子数里挑选随机数
numpy.random.seed(2)

x=numpy.random.normal(3,1,100)
y=numpy.random.normal(150,40,100)/x

train_x=x[:80]
train_y=y[:80]

test_x=x[80:]
test_y=y[80:]

#多项式拟合函数np.polyfit(x,y,num)
mymodel=numpy.poly1d(numpy.polyfit(train_x,train_y,4))
r2=r2_score(train_y,mymodel(train_x))
print(r2)

#计算测试集的拟合度
import numpy
from sklearn.metrics import r2_score
numpy.random.seed(2)
train_x=x[:80]
train_y=y[:80]
test_x=x[80:]
test_y=y[80:]
mymodel=numpy.poly1d(numpy.polyfit(train_x,train_y,4))
r2=r2_score(test_y,mymodel(test_x))
print(r2)

#预测值
print(mymodel(5))