博客

1 Python语言介绍&安装配置

1.1 Python数据相关应用

• 
  数据采集
  
  
  Scrapy为代表的各类方式的爬虫；beautiful soup数据解析
• 
  数据库连接
  
  
  大量各类数据库的第三方包，方便快速的实现增删改查；MySQL，Oracle，SQLite（python自带，简单易携带）
• 
  数据清洗
  
  
  Numpy、Pandas，结构化和非结构化的数据清洗及数据规整化的利器
• 
  数据分析
  
  
  Pandas、StatsModels（python内的统计模块）、Scipy（高级运算库），统计分析，科学计算、建模等
• 
  数据可视化
  
  
  matplotlib（最基本的库）、延伸bokeh、seaborn、gleam、plotly
• 
  机器学习和深度学习
  
  – python独树一帜
  
  scikits learn（机器学习的算法）、Keras、theano、pylearn2、caffe、lasagne

1.2 Python特点

• 运行效率不高
• 简单易学
• 面向对象的高层语言
• 解释性
• 免费开源，可移植性
• 可扩展性，可嵌入性
• 丰富的库

1.3 生成配置文件，修改默认路径

1. 使用管理员身份运行Anaconda Prompt

(base) C:\Users\C***e>jupyter notebook --generate-config   #生成配置文件
Writing default config to: C:\Users\C***e\.jupyter\jupyter_notebook_config.py

2. 找到文件，用txt打开，查找notebook_dir

## The directory to use for notebooks and kernels.
#c.NotebookApp.notebook_dir = ''       

3. 在非系统盘建立新的文件夹，复制路径
4. 删除“#”，c.NotebookApp.notebook_dir = 黏贴路径

## The directory to use for notebooks and kernels.
c.NotebookApp.notebook_dir = "D:\CDA\data\python"

5. 保存后退出

2 Python基础语法

2.1 关键字（即保留字）

不能用作任何标识符名称

import keyword 
print(keyword.kwlist)  # 显示关键字列表

2.2 输入和输出

• 
  输入
  

d = input("请输入一个数字：")  # input函数接受一个标准输入数据，返回为 string 类型
type(d)  # type() -- 只有第一个参数则返回对象的类型，三个参数返回新的类型对象
isinstance(1,float) # isinstnce 一个对象是否是一个已知的类型，类似 type() 
					# 表示判断1是否为浮点型

# type不会认为子类是一种父类类型，不考虑继承关系；isinstance则相反
# 判断两个类型是否相同推荐使用 isinstance

• 
  输出
  

d
print(d)
print("输出指定文字")  # print() -- 输入字符串，可向屏幕输出指定文字

2.3 声明变量

• 声明变量不能使用数字开头
• 关键字（keyword直接报错），内置函数（赋值后报错，不能使用函数）
• 第一个字符可用字母或”_”，对大小写敏感

2.4 自增运算

3 标准数据类型

3.1 布尔值bool

• 
  False
  
  
  0 ； ” “空字符串 ； [ ]空列表 ； { }空集合 ； ( )空元组
• 
  True
  
  
  1 ；其他情况

3.1.1 布尔值的运算符

3.2 数字numbers

• 
  整数int
  
• 
  小数float
  
  
  在python是不精确储存，用decimal进行计算

import decimal   # 加载decimal模块
decimal.Decimal('1.1')+decimal.Decimal('1.1')+decimal.Decimal('1.1')
Decimal('3.3')

注： 变量的唯一识别

数值相等，数值为小数，指向不同对象

数值相等，数值为整型且小于256，指向同一个对象，大于256，重新声明，指向不同对象

• 
  复数complex
  

(2 + 3j).real  # 复数的实数部
>>2.0
(2 + 3j).imag  # 复数的虚数部
>>3.0

3.2.1 数字间转换

int(3.99)  # int() -- 截取小数的整数部分;将字符串转换成整型
>>3
int('44')  # 将'字符串'转换为整型
>>44
round(4.5)  # round() -- 四舍五入，在.5时，奇进偶舍round（4.5）返回4；round（5.5）返回6
>>4
complex(1,2)  # complex() -- 创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数
>>(1+2j)

3.3 字符串 String

• 使用英文符号’ ‘括起来
• 空格也是代表一个字符

1. 字符串&列表&元组运算符

2. 转义字符

3.3.1 常用字符串操作

str_1.count('p')  # .count() -- 计算字符串里的指定字符数
len(str_1)  # 计算字符串长度
str_1.upper().lower() # .upper() -- 字符串转换为大写
                      # .lower() -- 字符串转换为小写
str_2.title()  # .title() -- 字符串首字母大写

# .split() -- 分割
str_2.split()  #以空格分割
str_2.split('h')  #以h分割

# "指定字符".join() -- 拼接多个字符串；在单个字符串插入字符
"#".join(["fhka","hla","fdak"])  # 使用“#”拼接多个字符串
"$".join("fhka") # 在字符串内插入“$”单个字符

# .replace(a,b(,n)) -- 替换;用b替换前n个a
str_2.replace("y","Y") # 用Y替换全部的y
str_2.replace("y","Y",2) # 用Y替换前两个字符串的y

# .find(a(,n,m)) -- 查找字符的位置;查找从第n至m个字符开始出现a的位置；-1表示没有找到
str_2.find("p") # 查找p第1次出现的位置
str_2.find("p",2) # 查找从第2个字符开始出现p的位置
str_2.find("p",2,5) # 查找从第2-5个字符间开始出现p的位置；-1表示没有找到

# "字符{}字符{}".format("字符",值) -- 字符串格式化
for i in range(4):      # i从0开始到4，分别运算
    print ("i的值为{},i的平方为{}".format(i,i**2))
i的值为0,i的平方为0
i的值为1,i的平方为1
i的值为2,i的平方为4
i的值为3,i的平方为9

# 查询--in、startswith、endswith
"pe" in str_2  # "字符" in 字符串 -- 查询字符是否在字符串里，返回true或false
str_2.startswith("p")  # .starwith("字符") -- 查询字符串是否以指定字符开头，返回true或false
str_2.endswith("t")  # .endwith("字符") -- 查询字符串是否以指定字符结尾，返回true或false

# 字符串&列表&元组切片
## 字符串[索引x:索引y:跳z位] -- 包含起始值，不包含结尾值
## 从索引0开始算字符位置
str_2[1:9:2]  # 第三个数值代表跳n-1位
str_2[9:1:-2]  # -表示倒序；从第9位到第1位数
str_2[::-1]  # 倒序

3.4 列表 List

• 列表是存储元素，有序的容器
• 用[ ]表示

3.4.1 常用列表操作

len(L)  # 求列表长度，查看元素个数

L = [[1, 2], 'string', {}]  # 嵌套列表
L = list('spam')  # 列表初始化
L = list(range(0, 4))  # 列表初始化

list(map(ord, 'spam'))  # 列表解析

L.count(value)  # 求列表中某个值的个数
L.index(value, [start, [stop]])  # 返回列表中值value的第一个索引

# 添加数据
L.append(obj)  # 向列表的尾部添加数据，比如 append(2)，添加元素2；若是多个元素，当作一组添加
L.insert(index, obj)  # 向列表的指定index位置添加数据，index及其之后的数据后移
L.extend(interable)  # 通过添加 iterable 中的元素来扩展列表，比如 extend([2])，添加元素2，注意和append的区别，可插入多个元素

# 排序
L.reverse()  # 倒序；反转列表
L.sort(cmp=None, key=None, reverse=False)  # 排序；同样数据类型才可排序;TRUE降序

# 删除数据
L.pop([index])  # 删除并返回index处的元素，默认为删除并返回最后一个元素
L.remove(value)  # 删除列表中的value值，只删除第一次出现的value的值
L.clear() # 清空列表的数据

3.4.2 切片赋值

List[index]=value  # 将索引为n的元素更换为新的值
List[index:index]=[value,value]  # 将n个元素替换对应m个值
List[index:index]=[value(,value...value)]  # 可将n个元素替换为单个或多个值

3.5 元组 Tuples

• 元组是存储元素，有序的容器
• 元组的元素不能修改
• 用( )表示

3.5.1 常用列表操作

len(Tup)  # 查看元组内元素个数
Tup[index].append(value)  # 元组元素不能修改，若元组元素是列表，列表内元素可修改

"value" in Tup  # 查找指定值是否在元组，返回True or Flase

max(Tup)  # 若元组内均为类型，可输出最大的元素
min(Tup)  # 若元组内均为类型，可输出最小的元素

Tup.count(value)  # 元组中指定值的个数
Tup.index(value)  # 元组中指定值的索引

3.6 字典Dictionaries

• 键-值 对应储存
• 键是唯一的，值可以重复
• 字典是无序的，没有索引，不能切片
• 用{ }括起来，键和值用:链接

3.6.1 常用字典操作

D = {}
D = {'spam': 3, 'tol': {'ham': 8}}  # 嵌套字典
D = dict.fromkeys(['c', 'h'], 8)  # {'c': 8, 'h': 8}
D = dict(name='tiger', age=25)  # {'age': 25, 'name': 'tiger'}
D = dict([('name', 'tiger'), ('age', 25)])  # {'age': 25, 'name': 'tiger'}
D = dict(zip(['name', 'age'], ['tiger', 25]))  # {'age': 25, 'name': 'tiger'}

# 查询
D.keys()  # 查询字典中所有的键
D.values()  # 查询字典中所有的值
D.items()  # 字典键、值以及键值对；将字典转换成有序
D.get(key, default)  # get函数，查询键对应的值

# 添加键值对
D.update(D_other)  #  添加键值对，如果存在相同的键值，D_other的数据会覆盖掉D的数据
D.setdefault(k[, d])  # 不重复添加键值对；添加判断原字典是否存在键，若无，添加键值对；否则不添加修改

# 删除键值对
D.pop(key, [D])  # 删除字典中键值为key的项，返回键值为key的值，如果不存在，返回默认值D，否则异常
D.popitem()  # pop字典中随机的一项（一个键值对）
D.clear()  # 清空字典
del D['key']  # 删除字典的某一项

# 删除字典
del D  # 删除字典

3.7 集合 Set

• 是key的集合，不存储value
• key不能重复，集合没有重复的值
• 存储不可变对象

3.7.1 常用集合操作

# 添加键
s.add(value)  # 添加键
s1.update(s2)  # 添加集合的键

# 集合的运算
s1 & s2   # 交集
s1 | s2  # 并集
s1.union(s2)  # 并集，去重

# 删除键
s.pop()  # 从头逐个删除键
s.remove(key)  # 删除指定键

# 清空集合
s.clear()  # 清空集合

3.8 空值 None

• 特殊的值

4 控制流语句

4.1 顺序结构

• 从上到下，从左到右，逐条运行
• 即使有一句出错，不影响之前的运行

4.2 分支结构

• 只会满足1个条件
• if可以单独存在，elif和else必须依赖if的存在而存在

score = 68
if score > 85:
    print("A")
elif score>70:
    print("B")
elif score>60:
    print("C")
else:
    print("D")

4.3 循环结构

while语句或者for语句可以带else语句 当然也可以带continue/break/pass语句

• 
  break
  
  语句 – 用来终止最内层的循环
• 
  continue
  
  语句 – 用来跳过最内层当前次的循环
• 
  pass
  
  是空语句，为保持程序结构的完整性

4.3.1 while循环

• 知道限制条件用while
• while容易死循环

while a > 1:
    anything
else:
    anything
# else语句会在循环结束后执行，除非在循环中执行了break，同样的还有for语句

4.3.2 for循环

• 能用for循环不用while循环；知道循环次数

for i in range(5):
    anything
else:
    anything

• for循环的
  
  元组赋值
  

for (a, b) in [(1, 2), (3, 4)]:  # 最简单的赋值
for ((a, b), c) in [((1, 2), 3), ((4, 5), 6)]:  # 自动解包赋值
for ((a, b), c) in [((1, 2), 3), ("XY", 6)]:  # 自动解包 a = X, b = Y, c = 6
for (a, *b) in [(1, 2, 3), (4, 5, 6)]:  # 自动解包赋值

5 常用内置函数

5.1 逻辑判断

all([1,2,2,0])  # 如果其中所有的值都为真返回Ture，为空时也返回Ture
any([1,0,4,3])  # 其中1个为真返回Ture，为空或全部假时返回False
isinstance(5,int)  # isinstanc(参数,类型) -- 判断参数是否指定类型

5.2 数学相关

abs(-16392)  # 求绝对值
divmod(78,5)  # 除法运算，返回商和余数
pow(2,6,3)  # pow(x,y[,z]) -- 返回以x为底，y为指数的幂；若有z值，计算x的y次幂被z取模的值
round(3.1415926,4)  # round(x[,n]) -- 四舍五入，n为小数点后位数
min(321,52345,5634,21,634)  # min(x[,y,z...]) -- 返回参数最小值；若对比列表中的序列，索引为0的值的大小
min([1,7,8],[2,3,4,5],key=lambda x:x[1])   # lambda x:x[1] 切片,按照列表中第1个索引对比
max(321,52345,5634,21,634)  # max(x[,y,z...]) -- 返回参数最大值，可为序列
sum([321,52345,5634,21,634])  # 返回序列或集合中的数字总和

5.3 序列相关

len("fhajklfhl327954")  #返回字符串或序列的长度
range(10)   # range([lower,]stop[,step]) -- 按参数生成连续的有序整数列表;起始值，终止值，步长

list(range(10))  # [*函数(...)]等同于list(函数(...))；惰性序列，节省内存
[*range(1,10,2)]  #索引从1到10，隔1位取数；把数字拆开，重新组成列表
[range(1,10,2)] # 把整个range对象存在列表
[range(1, 10, 2)]

list(filter(lambda x:x>0,[1,-2,-3,4]))  # filter(func,iterable) -- 判断序列中每个元素得到布尔值,True则留下
def func(x):
    return x>0
list(filter(func,[1,-2,-3,4]))

list(map(lambda x:x+1,L))  # map(func,*iterable) -- 处理所有元素，对象中的元素个数和位置与原来一样，返回map对象，即可迭代对象(列表，元组，range,字符串)

reversed(sequence) -- 翻转序列
sorted() -- 同类型比较大小，排序

zip([1,2,3],[4,5,6])  # 将多个序列输出为一一对应的zip对象
[*zip([1,2,3],[4,5,6])]

5.4 类型转换

bool("")  # 转换为布尔类型
int(value)  # 转换为整数；截取整数部分
float(value) # 转换为浮点数
str(value)  # 转换为字符串;若是列表，则整个转换成文本
dict(iterable)  # 转换为字典；键值对，键不重复
list(iterable)  # 转换为列表
tuple(iterable)  # 转换为元组
set(iterable)  # 转换为集合；无序不重复
complex()  # 创建一个复数
enumerate(["a","b","c","d"],1)  # 将数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出索引和对应数据
[*enumerate(["a","b","c","d"],1)]

5.5 系统函数

id()  # 返回对象的唯一标识值
help()  # 调用系统内置的帮助系统;?;shift+Tab
type()  # 返回对象的数据类型
input()  # 获取用户输入信息；返回的是字符串
open()  # 打开文件
print()  # 打印函数
eval()  # 将字符串作为代码运行，多与input结合

6 自定义函数

# return语句 -- 退出函数，返回一个表达式
def total(x,y=100):  # 定义函数 不输入y，默认y=100
    sum_total=0
    for i in range(x,y):
        sum_total += i
    return(sum_total)  


def gensquare(N):
    for i in range(N):
        yield i ** 3  # 状态挂起，可以恢复到此时的状态
for i in gensquare(4):  # 使用方法
    print(i, end=' ')  # [0, 1, 8, 27]
x = gensquare(2)  # x是一个生成对象
next(x)  # 等同于x.__next__() 返回0
next(x)  # 等同于x.__next__() 返回1
next(x)  # 等同于x.__next__() 抛出异常StopIteration

6.1 函数的参数

• 
  必须参数
  
  
  必须以正确的顺序传入参数，不能颠倒
• 
  命名参数
  
  
  关键字参数；用参数命名确定传入的参数
• 
  默认参数
  
  
  缺省参数；不传递参数，使用参数默认值
  
  *注：必选参数在前，默认参数在后
• 
  不定长参数
  
  
  可变参数；即传入的参数的个数可变，0个，1个，n个
  
  *arg –

def total(x,*arg):  # *名称--不定长参数;*--列表，序列；**--字典，键值对
    result = x
    for i in arg:
        result += i
    return(result) 

6.2 变量作用域

x = int(2,9)  #内建作用域；B；Built-in;python的内建函数，不会因为解释器的改变而改变

g-count = 0  # 全局作用域；G；Global
def outer():
    o-count = 1  # 闭包函数外的函数中；E；Enclosing
    def inner():
        i-count = 2  # 局部作用域；L；Local
        print(i-count)
        print(o-count)
        print(g-count)
    inner()
outer()

6.3 Lambda匿名函数

f = lambda x, y, z: x + y + z  # 普通匿名函数，使用方法f(1, 2, 3)
f = lambda x=1, y=1: x + y  # 带默认参数的lambda函数
def action(x):  # 嵌套lambda函数
    return (lambda y: x + y)
f = lambda: a if xxx() else b  # 无参数的lambda函数，使用方法f()

7 高级函数

7.1 if/else三元表达式

A = 1 if X else 2
A = 1 if X else (2 if Y else 3)

7.2 生成器表达式（不占内存）

G = (x ** 2 for x in range(3))  # 使用小括号可以创建所需结果的生成器generator object
next(G), next(G), next(G)  # 和上述中的生成器函数的返回值一致
# （1）生成器(生成器函数/生成器表达式)是单个迭代对象
G = (x ** 2 for x in range(4))
I1 = iter(G)  # 这里实际上iter(G) = G
next(I1)  # 输出0
next(G)  # 输出1
next(I1)  # 输出4
# （2）生成器不保留迭代后的结果
gen = (i for i in range(4))
2 in gen  # 返回True
3 in gen  # 返回True
1 in gen  # 返回False，其实检测2的时候，1已经就不在生成器中了，即1已经被迭代过了，同理2、3也不在了

7.3 高级函数

# map函数--接收函数和序列2个参数，将函数依次作用到序列的元素，返回惰性序列，使用list打印
list(map(lambda x:x**2,a))

# reduce函数--累乘、累加；接收函数和序列2个参数，将结果继续和序列的下一个元素做积累计算
from functools import reduce   # 从functools包调用reduce
reduce (lambda x,y:x+y+10,[1,3,5,7,9])

# filter函数--过滤序列；将函数依次作用到序列的元素，根据返回值T or F决定保留或丢弃元素
def is_odd(n):
    return n%2==1
list(filter(is_odd,[1,2,3,5,467,3,754]))

def not_empty(x):
    return x and x.strip()   # 布尔值运算，x为0或F，返回x，所以不会报错;strip()去掉首尾的空格,空值
list(filter(not_empty,["a","fads","","   ",None]))  # ['a', 'fads']

# zip函数--将两个序列的相同索引的数值合成元组，以最小列的长度为准
list(zip(a,b,c))

# sorted函数--排序   *区别：L.sort只能用于列表
sorted(L,reverse=False)  # [3, 23, 65, 423, 464, 7565]
sorted(L,key=lambda x:x[1],reverse=True)  # [('Cathie', 89), ('Sylvia', 79), ('Sada', 70), ('Jowin', 65), ('Heman', 57)]

8 异常的处理

• 捕获程序中出现的异常，保证程序正常运行

#捕获异常
try:
except:  # 捕获所有的异常，等同于except Exception:
except name:  # 捕获指定的异常
except name, value:  # 捕获指定的异常和额外的数据(实例)
except (name1, name2):
except (name1, name2), value:
except name4 as X:
else:  # 如果在try部分没有引发异常
finally:  # 无论是否发生异常都执行
#引发异常: raise子句(raise IndexError)
raise < instance >  # raise instance of a class, raise IndexError()
raise < class >  # make and raise instance of a class, raise IndexError
raise  # reraise the most recent exception

9 包的导入

1. 包普通导入

import math
import numpy as np   # 数组运算，高级运算;as 简写
import pandas as pd

2. 包相对导入:使用点号(.) 只能使用from语句

from . import spam   # 导入当前目录下的spam模块（Python2: 当前目录下的模块, 直接导入即可）
from .spam import name  # 导入当前目录下的spam模块的name属性（Python2: 当前目录下的模块, 直接导入即可，不用加.）
from ..  import spam  # 导入当前目录的父目录下的spam模块

3. 包相对导入与普通导入的区别

from .string import *  # 这里导入的string模块为本目录下的(不存在则导入失败) 而不是sys.path路径上的

4. 导入自己编写的内容

• 新建python文件
• 导出.py文件
• 将文件放置系统路径
• import文件名调用
  
  *注：模块只能导入一次，若模块有更改，需重启服务后导入

10 文件基本IO操作

• 原生界面不好阅读

f = open(r'D:\bikes.csv', 'w')  # 若文件在工作路径文件夹，直接写文件名即可
f = open('data', 'r')  # 系统默认为'rt';'w'以覆盖方式写入文件, 'r'只读, 'a'写入追加内容，'b'用二进制模式显示,'t'用文本模式显示，'r+'，'w+'，'a+'，'wb', 'rb', 'ab'等

# 文件读取
f.readable()  # 文件是否可读
f.read([size])  # size为读取的长度，以byte为单位
f.readline([size])  # 读一行，如果定义了size，有可能返回的只是一行的一部分
f.readlines([size])  # 把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长。

# 文件写入
f.writeable()  # 文件是否可写
f.write(str)  # 把str写到文件中，write()并不会在str后加上一个换行符
f.writelines(seq)  # 把seq的内容全部写到文件中(多行一次性写入)

# 关闭文件
f.close()  # 关闭文件

# 判断编码
import chardet  # 导入转译编码模块
data = f.read()
chardet.detect(data) # 判断编码
f.close()  # 关闭文件
f = open("bikes.csv",encoding='ISO-8859-1')  # 消除乱码，重新打开文件

# walk()方法 -- 遍历目录返回（目录路径，所有子目录，非目录文件的名字）
import os
for i,j,k in os.walk("D:\CDA\data\python"):
    print(i)
    print(j)
    print(k)

# JSON数据解析
import json
d = dict(name="Bob",age=24,score=88)
json.dumps(d)   # json.dumps()--对数据进行编码

# 写入json数据
with open("text1.json","w")as f:
    json.dump(d,f)
# 读取json数据
with open("text1.json","r")as f:
    data = json.load(f)   # json.loads()--对数据进行解码

f.close()

11 查看全部模块路径

import sys
sys.path  # 查询python系统路径；当前的工作路径是权限最高的,按顺序从上往下找文件，同名文件优先调用工作路径
sys.argv  # 获得脚本的参数
sys.builtin_module_names  # 查找内建模块
sys.platform  # 返回当前平台 出现如： "win32" "linux"等
sys.modules  # 查找已导入的模块
sys.modules.keys()
sys.stdout  # stdout 和 stderr 都是类文件对象，但是它们都是只写的。它们都没有 read 方法，只有 write 方法
sys.stdout.write("hello")
sys.stderr
sys.stdin

12 OS模块

import os
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.linesep    #输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep    #输出用于分割文件路径的字符串
os.name    #输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  #运行shell命令，直接显示
os.environ  #获取系统环境变量