python基础和第三方库 笔记（python基础完结包括高级用法，第三方库持续更新中...）

python基础

注：本笔记面向有一定基础的人
本笔记是本人快速复习python过程中记录的，不适合零基础的人学习python的主工具，可以作为辅工具，本笔记记录了入门阶段常用操作，如有错误的地方，希望读者不吝赐教。

第一部分

1.1变量

# 1 打印变量类型
print(tpye(变量名))

# 2 打印变量/对象 内存id
print(id(变量))

# 3 list -- 列表
c=[10,2,1]

# 4 tuple -- 元组
c=(10,2,3)   

# 5 set -- 集合
c={10,2,1}

# 6 dict -- 字典
c={
    '1':1,
    '2':2,
}

1.2格式化输出,输入

学习内容 ：格式化符号，格式化方法，转义字符

格式符号	转换
%s	字符串
%d	有符号十进制数
%f	浮点数

%.3f   #保留几位小数
print('我的名字是%s 今年%d岁了' % (name,age))   #输出内容和数据绑定用%链接
%06d   #输出6位整数用0填充

#格式化字符串f'{表达式}'
print(f'我的名字是{变量名}，今年{age}岁了')

#转义字符
\n \t
#print默认以\n作为end，但可以显示声明其他结束符号
print('hello',end='...')    

#输入  input当作字符串处理，交给一个变量
input("提示信息")

1.3类型转换

函数	说明
int(x[,base])	。。。
flot(x)	。。。
str(x)	。。。
⭐eval(str)	计算字符串中有效的python表达式，返回一个对象
tuple(S)	。。。
list(S)	。。。

#把字符串里面的表达式转换为合适的类型
print(eval('[100,20]'))   #[100,20]

1.4运算符

#逻辑运算符
and or not

#python可以用类数学写法,下面写法是合法的语法
15<=a<=70

#三目运算符 化简简单的ifelse语句
c=a if a>b else b  #如果条件成立 c=a 否则c=b

1.5循环

# for和while后面都可以跟else 表示循环正常结束后执行，brek为非正常结束
while t<10:
    ...
else:
    ...

1.6⭐字符串

#切片  [开始:结束:步长 ] 其中若为二维数组则还可以这么些[开始:结束:步长,开始:结束:步长]  左闭右开不包括结束符，但是包括开始符、
#其中-7表示倒数第7个


#下列函数用法变量名.方法名
#---------------------查找--------------------
#find(子串，开始位置，结束位置)    查找是否存在某字串 返回第一次找到该字串所在母串中的位子 
mystr = 'hello world and itcast and itheima and Python'
print(mystr.find())  #12
#rfind()与find（）相同，从右往左查找
#count()和find（）的参数相同，返回出现次数
#index()与find（）完全相同，find未找到返回-1  index未找到返回异常

#---------------------修改1--------------------
#replace(旧字串，新字串，替换次数)  把旧字串替换为新字符串 
#split(字符串，次数)  返回是一个列表，用字符串分割split数组，其中次数代表的是分隔符出现的次数，次数为2分割后数据为3个
#join(多字符串组成的序列)    ！用法特殊！
'...'.join(['12','34'])  #12...34

#---------------------修改2--------------------
#capitalize()  第一个大写
#title()  每个单词首字母大写
#lower() 大写转小写
#upper()  小写转大写


#lstrip()    删除左侧空白
#rstrip()	 删除右侧空白
#strip()	 删除两侧空白

#---------------------格式化--------------------
#ljust(长度，填充字符)  左对齐 第二个参数不些默认空格填充
#rjust 	右对齐
#center  中间对齐
mystr='hello'
print(mystr.ljust(10,'.'))  #hello.....

#---------------------判断--------------------
#startwith(字串，开始，结束) 判断是否为字串开头  返回布尔类型
#endwith(字串，开始，结束)  判断是否为字串结尾
#isdigit()是否全是数字
#isalnum()是否是由字母和数字的组合组成
#isspace()是否全是空格

#注字符串的拼接直接用+号就可以

1.7⭐列表

#index   和字符串相关的函数一样
#count()   和字符串相关的函数一样
#len()   列表里面元素的个数

#判断某个数据是否存在 
in / not in
'lily' in name_list  #如果lily在name_list中返回true  
'lily' not in name_list

#添加数据
#append(元素) 把元素添加到列表尾  如果是序列则把整个序列添加进列表
#extend()   同上，但参数可以是一个序列，并且把该序列所有元素依次添加进列表
#insert(位置下表，数据)   指定位置增加数据

#删除数据
#del(数组变量/下标)     删除列表 把整个列表删除 或者删除下标元素
#pop()      删除指定位置元素 默认删除最后一个数据  返回被删除的数据
#remove()  删除指定元素
#clear()  清空

#修改
#reverse()   反转列表
#sort(key=None,reverse=False )    列表 reverse为False 升序

#列表复制
#copy()  注：python中列表只有一个存储，所有的名字都执行同一个空间，可以当作指针理解，因此修改列表需要复制一份然后再删除

1.8元组

元组中的数据不能修改 ,元组数据不能修改，但是元组里面有列表，列表中的数据可以修改

t1=(1,2,3)
print(t1[1])  # 2
print(t1.index(2)) #1

t1=(1,2,[1,2])
t1[2][0]=2
print(t1)   #(1,2,[2,2])

#只有一个元素的元组要这么写
(1,)

1.9字典

#新增数据
dic['1']='2'  #如果dic中没有‘1’这个key值则添加新的键值对，如果key存在则修改

#删除
#del()同列表
#clear()同列表用法相同

#查找
dic['1']
dic.get('1',2)  #如果查找不到key为'1'则返回默认值2

#遍历字典
#counts.items()为字典的迭代器，获取到的是字典中的键值对元组
dic1={'name':1,'age':2,'gender':3}
for key,value in dic1.items():
    print(f'{key}={value}')  
#！！对字典进行拆包得到的是key！！

1.10集合

去重，和列表相比 集合里面没有重复的数据

#创建集合
s1={1,2,3}
s1=set()  创建空集合  #注：s1={}表示s1为空字典

#增加数据
#add()  s1.add(10)  如果重复不进行任何操作
#updata()   ！注意增加的数据是列表

#删除数据
#remove  删除指定数据，   ！没有不报错！
#discard()  删除指定数据   ！没有报错！
#pop() 随机删除数据并返回删除的数据

#查找数据
in / not in

第二部分

2.1公共运算

2.1.1运算符

运算符	描述	支持的容器类型
+	合并	字符串、列表、元组
*	复制	字符串、列表、元组
in	元素是否存在	字符串、列表、元组、字典
not in	元素是否不存在	字符串、列表、元组、字典

2.1.2公共方法

函数	描述
len()	容器元素个数
del del()	删除
max()	容器元素最大值
min()	容器元素最小值
range(start,end,step)	生成从start到end的数字，步长为step，供for循环使用
enumerate(可遍历对象，start=0)	函数用于将一个可遍历的数据对象组合为一个索引序列，同时列出数据和数据下表，一般用在for循环当中。start为遍历对象下表起始值(计算机默认为0可以手动调节为1) 返回值为index,value

2.1.3容器类型转换

• tuple()
• list
• set()

2.2推导式

更有风格的python代码书写,代码量更少

2.2.1列表推导式

用一个表达式创建一个有规律的列表，或者控制一个有规律的列表

• 创建有规律的列表

list1=[i for i in range(10)]   #其中左面的i是回填的数据格式，右面的i是生成的i 还可以在继续对i添加if条件，满足条件才回填
print(list1)
# [0,1,2,3,4,5,6,7,8,9]

#创建偶数的列表
list1=[i for i in range(10)  if i%2==0 ]   
print(list1)
# [0,2,4,6,8]

#多for循环
list1=[(i,j) for i in range(1,2) for j in range(3)]   
print(list1)
#[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

2.2.2字典推导式

快速合并列表为字典或者提取字典中目标数据

• 创建字典

dic={i:i**2 for i in range(1,5)}
print(dic)
#{1: 1, 2: 4, 3: 9, 4: 16}

• 把两个列表合并为一个列表

list1=['张三','李四','王五']
list2=[18,20,13]
dic={list1[i]:list2[i] for i in range(len(list1)) }
print(dic)
#{'张三': 18, '李四': 20, '王五': 13}

• 提取字典中的目标数据

#提取counts中的value满足一定条件的数据
counts={'map':123,'hp':1233,'dell':298,'acer':981}
count1={key:value for key,value in counts.items() if value>=200}   #!注： counts.items()为字典的迭代器，获取到的是字典中的键值对元组
print(count1)
#{'hp': 1233, 'dell': 298, 'acer': 981}

2.2.3集合推导式

list1=[1,1,2]
#返回list1中每个数据的二次方组成的集合
set1={i **2 for i in list1}
print(set1)
#{1,4}

2.3函数

#查看函数说明文档
def 函数名(参数):
	"""说明文档"""
	代码
	......
help(函数名)  

2.3.1修改全局变量

a=100
def test():
    global a    #声明a为全局变量的a
    a=200
    return

text()
print(a)
#200

2.3.2参数写法

*args **kwargs

其中的*可以看作一个运算，可以把1，2，3，4这种用逗号隔开的数据变为一个元组（1，2，3，4）也可以把（1，2，3，4）变为1，2，3，4

**则是把age=20,name='asd'用逗号隔开的key=value复制变为一个字典，反过来也可以把字典变为key=value赋值

• 位置参数

def function(name,age,gender):
    .....
# 传入参数的时候根据位置传入对应的形参

• 关键字参数

fdef function(name,age,gender):
    .....
function('张三',gender='nv',age=18)
# 位置参数放在关键字参数之前，关键字参数顺序对结果无影响

• 缺省参数

def function(name,age,gender,test='1'):
    .....
function('张三',18,'男')   #此时默认test=1
function('张三',18,'男',2)   #此时test=2

• 包裹位置传递（不定长传递）得到的是一个元组，位置和传入时相同

#  默认用*args作为不定长参数的传递   
def user_info(*args):  
    #这里的args是一个元组
    print(args)
    
#('Tom',)
user_info('Tom')
#('Tom',18)
user_info('Tom',18)

• 包裹关键字传递（不定长传递）得到的是一个字典

def user_info(**kwargs):
    print(kwargs)
    
user_info(name='tom',age=18,id=110)

2.3.3交换变量

a,b=b,a  #交换ab的值

3.3.4引用

在python中，值是靠引用传递过来的

a=1,b=a 此时b就是a的引用

函数值传递过程中实参的传送可以是引用

a=1
b=a  #此时b是a的引用，指向同一块内存空间
#id()可以判断两个变量是否是同一个值的 引用可以理解为id是内存地址的标识

• 不可变类型的引用（整形，浮点型，字符串，元组)

a=1
b=a
#此时id(a)与id(b)是一样的
a=2
#此时id(a)与id(b)是不一样的  并且a=2,b=1   a改变了因此开辟了一块新的空间存储新的值

• 可变数据类型的引用(列表，字典，集合)

aa=[10,20]
bb=aa
bb[0]=11
print(aa)
#[11,20]
#注意通过函数传送的值也是引用，函数体内如果要修改数组，记得copy一下
在修改数组

2.3.5⭐lambda表达式

如果函数只有一个返回值，并且只有一句代码，可以使用lambda简化

lambda 参数列表： 表达式（返回值）

fn2=lambda :100   #fn2是一个函数
print(fn2)      #打印的是内存地址
print(fn2())      #是函数返回值

• 参数形式

pritn(fn1(1,2,3))fn1 =lambda a,b:a+b   #有参数

fn1 =lambda a,b,c=100:a+b+c   #默认参数

fn1 =lambda *args:agrs   #可变参数 元组
pritn(fn1(1,2,3))

fn1 =lambda **args:agrs   #可变参数 字典
pritn(fn1(name='c',age=2))

• lambda应用

fn1= lambda a,b : a if a>b else b
print(fn1(1000,500))   #1000

#列表(里面是字典）根据字典某个确定key的value值进行排序
student=[{'name':'ad','age':20},{'name':'a','age':30},{'name':'ab','age':10}]
student.sort(key=lambda x:x['age'])   #这里的x代指列表里面的字典  根据字典中的name的value值排序
print(student)   #[{'name': 'ab', 'age': 10}, {'name': 'ad', 'age': 20}, {'name': 'a', 'age': 30}]

2.3.7⭐高阶函数

把函数作为参数传入，函数式编程的体现,

• 思路分析

def function(a,b)
	return abs(a)+abs(b)
def function(a,b)
	return round(a)+round(b)

#上面两个函数可以写为一个
def function(a,b,f)  #f是一个函数
	return f(a)+f(b)

result=function(1,2,abs)
result=function(1.2,2.7,round)

• 内置高阶函数

函数	作用
map(func,lst)	将传入的函数变量func作用到lst变量的每个元素中，结果返回迭代器（python3)返回（需要进行过类型变换）
reduce(func,lst)	func必须有两个参数。作用是func(func(func(func(func(func(a,b),c),d),e),f),g)
filter(func,lst)	过滤到不符合func条件的元素，返回一个filter对象，如果转换为列表用list()

#----------------map(func,lstt)-----------------
list1=[1,2,3,4,5]
def func(x):
    return x**2
result=map(func,list1)
print(result)  #内存地址
print(list(result))   #列表

#----------------reduce(func,lstt)-----------------
#list1累加
def func(a,b):
    return a+b
result=reduce(func,lst1)
print(result)  #整形

#----------------filter(func,lstt)-----------------
#需要的是一个返回布尔型的函数
def func(a):
    return x%2==0  
result=filter(func,lst1)
print(result)  #内存地址
print(list(result))   #列表

2.4面向对象

类名函数 满足大驼峰命名 变量满足小驼峰

print(类名.__mro__)   #打印当前类所继承的父类及其层级关系
print(类名/实例名.__dict__)  #打印类或者实例里所有的属性和方法组成的字典

2.4.1python面向对象特点

• self == this

# self指代调用该函数的对象，可以通过self访问该对象的数据 相当于this
class Washer():
    def was(self):
        print(self)


test = Washer()
print(test)
print(test.was)

• 多例

class Washer():
    def was(self):
        print(self)


test1 = Washer()
test2=Washer()
#test1 与test2 不一样，python的对象是多例的

• 类的属性

#类外面添加属性  这是和别的编程语言不同的
class Washer():
    def was(self):
        print(self)
test = Washer()

test.widteh=500
test.height=800

#类的外面获取属性  对象名.属性名
 
#类里面获取属性  self.属性名   只能获取对象拥有的属性

2.4.2⭐魔法方法

# __xx__()形式的函数叫做魔法函数，用作特殊作用

• 初始化魔法函数

class Washer():
    def __init__(self):  #在创建对象的时候自动执行      无参
        self.width=500
        self.heigth=300
    def was(self):
        print(self)
test = Washer()

class Washer():
    def __init__(self，width,height):  #在创建对象的时候自动执行      无参
        self.width=width
        self.heigth=height
    def was(self):
        print(self)
test = Washer()

• str魔法方法

#打印对象实际上打印的是对象的内存地址，如果定义了__str__方法，那么就会打印从这个方法中return的数据
class Washer():
    def __init__(self):  #在创建对象的时候自动执行      无参
        self.width=500
        self.heigth=300
    def was(self):
        print(self)
    #str魔法方法大多都是介绍该类的作用
    def __str__(self):  
        return "这是一个洗衣机类"
result=Washer()
print(result)  #这是一个洗衣机类

• del魔法方法

class Washer():
    def __init__(self):  #在创建对象的时候自动执行      无参
        self.width=500
        self.heigth=300
    def was(self):
        print(self)
    #str魔法方法大多都是介绍该类的作用
    def __del__(self):
        print("对象已经删除")
result=Washer()   
del result  #对象已经删除  注意不用手动del，在程序执行完后会自动删除对象，执行del魔法方法

• call魔法方法

带有call魔法方法的类可以当作函数一样调用

class Check(object):
    def __call__(self,*args,**kwargs):
        pritn("我是call方法")
c=Check()
c()   #向函数一样调用该类对象的call方法

2.4.3继承/私有权限

#object是继承，默认继承顶级类就是object类
class 类名(object):
	代码
    
print(类名.__mro__)   #打印当前类所继承的父类及其层级关系

继承默认继承父类的所有属性和方法

多继承默认使用第一个类的同名属性和方法

• 方法重写

#子类重写父类同名方法,默认使用子类的同名方法,那么如何利用父类的同名方法呢

class Master(object):
    def __init__(self):
        self.kongfu='123'
    def make_cake(self):
        print(f'利用{self.kongfu}')
class Prentice(Master):
    def __init__(self):
        self.kongfu='1'
    def make_cake(self):
        print(f'利用{self.kongfu}')
    #在子类中把和父类重名的方法重新写一遍,Master代指父类
    def father_master_make_cake(self):
        Master.__init__()
        Master.make_cake()

• super()调用父类的方法

# 调用本类的直接父继承的方法  遵循mro类属性顺序,适合单继承使用
super().方法名

• 私有属性/方法

私有权限不会继承给子类

# 属性名以__开头的是私有属性,__开头的是私有方法
class Master(object):
    def __init__(self):
        self.kongfu='123'
        self.__money=20000
    def __info_print(self):
        print(f'我的资产{self.__money}')

#获取和修改私有属性  只能在类内获取和修改私有属性
class Master(object):
    def __init__(self):
        self.kongfu='123'
        self.__money=20000
    def __info_print(self):
        print(f'我的资产{self.__money}')
    #获取和修改私有属性的值
    def get_money(self):
        return self.__money=money:
    def set_money(self,money):
        self.__money=money

2.5.4多态

子类重写父类的方法，传入不同的子类，执行不同的方法

class Dog():
    def work(self):
        print("开始工作")
class ArmyDog(Dog):
    def work(self):
        print("追击敌人")

class DrugDog(Dog):
    def work(self):
        print("追击毒品")

class ClassificationDog():
    def work(self,dog):
        dog.work()

cd=ClassificationDog()
ad=ArmyDog()
dd=DrugDog()
cd.work(ad)   #追击敌人
cd.work(dd)   #追击毒品

2.5.5类属性/方法/静态方法

类拥有的属性,被该类所有的对象所共享,可以用实例对象访问,也可以用类来访问

• 设置和访问类属性

class Dog(object):
    tooth=10      #这就是类属性

• 修改类属性

类属性只能通过类修改,无法通过实例修改,如果实例修改类属性,则是创建和类属性同名的实例属性而已

class Dog(object):
    tooth=10      #这就是类属性
    
  
wangcai=Dog()
Dog.tooth=12
print(wangcai.tooth)  #12

• 类方法

需要用装饰器@classmethod

类方法用来获取类私有属性 类方法用类名或者实例对象名访问

class Dog():
    __tooth=10
    @classmethod
    def get_tooth(cls):   #cls指代的是类,self指代的是实例对象
        return  cls.__tooth

test=Dog()
print(test.__tooth)  #报错
print(test.get_tooth)  #10

• 静态方法

用装饰器staticmethod来修饰,不需要传递对象不需要传递实例对象 即没有self或者cls

静态方法也可以通过实例对象和类对象访问

class Dog():
    @staticmethod
    def info_print():
        print('这是一个狗类用于创建狗实例...')
test=Dog()
test.info_print()
Dog.info_print()

2.5异常

2.5.1错误异常

• 写法结构

try:
    可能发生异常的代码
except:
    发生异常后执行的代码

• 捕获指定异常类型/打印异常描述

#单个
try:
    可能发生异常的代码
except 异常类型:
    发生异常后执行的代码
#多个   
try:
    可能发生异常的代码
except (异常类型1,异常类型2):
    发生异常后执行的代码
    
#捕获异常描述类型
try:
    可能发生异常的代码
except (异常类型1,异常类型2) as result:
    print(result)
    
#!!其中Exception代表所有异常!!

• 异常的else finally

try:
    可能发生异常的代码
except Exception as result:
    print(result)
else:
    没有异常后执行的代码
finally:
    无论如何都会执行的代码

• 异常传递

异常可以嵌套

import time
try:
    f=open('test.txt')
    try:
        while True:
            content=f.readline()
            if(len(content)==0):
                break
            time.sleep(2)
            print(content)
    except:
        print('意外终止了读取数据')
    finally:
        f.close()
        print('关闭文件')
except:
    print('无法打开该文件')

2.5.2自定义异常

不符合程序逻辑要求 把其设置为异常来提醒用户

1. 自定义异常类
2. 抛出异常 raise关键字加异常类(如有初始化参数写在这里)
3. 捕获异常

# 自定义异常
class ShotrInputError(Exception):
    def __init__(self, length, minlength):
        self.length = length
        self.minlength = minlength

    # 异常抛出信息
    def __str__(self):
        return f'您输入的长度为{self.length}，不能少于{self.minlength}'
# 测试类
def test():
    try:
        con = input('请输入密码:\n')
        if (len(con) < 10):
            # raise抛出异常
            raise ShotrInputError(len(con), 10)
    except ShotrInputError as result:
        print(result)
    else:
        print('密码已经输入完成')
# 测试开始
test()

2.6模块和包

2.6.1自己写的模块

如果import则会导入所有，包括测试，那么如何让测试只在模块内调用呢？

# 自定义异常
class ShotrInputError(Exception):
    def __init__(self, length, minlength):
        self.length = length
        self.minlength = minlength

    # 异常抛出信息
    def __str__(self):
        return f'您输入的长度为{self.length}，不能少于{self.minlength}'


def test():
    try:
        con = input('请输入密码:\n')
        if (len(con) < 10):
            # raise抛出异常
            raise ShotrInputError(len(con), 10)
    except ShotrInputError as result:
        print(result)
    else:
        print('密码已经输入完成')


# 其中如果在当前模块运行则__name__==__main__，如果不是在当前模块，比如被别人导入了本模块 ，则__name__等于模块名
if __name__ == '__main__':
    test()

搜索模块顺序

1. 当前目录 （注：自己的文件名不要和已有的模块名重复)
2. pythonpath目录下的每个目录 虚拟环境的目录
3. 默认路径

2.6.2all列表

如果一个模块中有all变量，，使用from xxx import *导入时，只能导入这个列表中的元素(即把模块功能写近all列表中，导入的时候只导入注册到all列表中的方法)

#这是一个模块
__all__=['test1']

def test1():
    print('test1')
def test2():
    print('test2')
#只有test1方法能被导入到其他文件中

2.6.3包

文件夹，里面是一些有联系的模块。包里面有个init.py文件，用于控制导入包的内容

init.py 里面添加all=[]，里面写上允许导入的模块名

第三部分

在本部分中将介绍python的高级用法包括进程线程 装饰器等

3.1程序的并行和并发

3.1.1多进程

创建子进程实际上把主进程的资源拷贝了一遍，他们俩之间互不干扰。因此不共享全局变量

• 创建子进程

# 1 导入模块 multiprocessing 创建进程对象 并启动
def func_a():
    for i in range(5):
        print('A进程在执行')
def func_b():
    for i in range(5):
        print('B进程在运行')
        
if __name__ == '__main__':
    process1=multiprocessing.Process(target=func_a)
    process2=multiprocessing.Process(target=func_b)
    process1.start()
    process2.start()
# 2 执行带有参数的任务
process1=multiprocessing.Process(target=func_a,args=(1,2,3))  #args传送参数元组方式，kwargs后面跟字典
process2=multiprocessing.Process(target=func_b)
process1.start()
process2.start()

• 获取进程编号

# 1 获取进程编号
import os
getpid()  #获取当前运行进程编号
getppid()  #获取当前父进程编号

• 进程结束顺序

主进程等待所有子进程工作后才会结束

# 1 主进程默认等待所有子进程的执行
def func_a():
    for i in range(10):
        print('工作中...')
        time.sleep(0.2)
if __name__ == '__main__':
    process1=multiprocessing.Process(target=func_a)
    process1.start()
    time.sleep(1)
    print('主进程工作完成')

# 2 主进程结束后，子进程自动结束 【1 设置子进程为守护主进程，主进程完成后，子进程会自动结束】【2 也可以手动销毁子进程】
process1.daemon=True 
peocess1.start()   #【方法一】

process1.terminate()   #【方法二】

3.1.2 多线程

• 多任务可以利用多线程使用，进程会分配资源，线程只是执行，不会分配资源

  比如：要给两人两天两个窗口 如果用多进程则每个窗口都有资源，如果用多线程就会节省资源

• 线程之间的执行是无序的，由cup调度决定

• 线程之间共享全局变量

# 1 创建多线程  【和多进程类似只不过把名字变了】
import threading
import time
def func_a():
    for i in range(10):
        print('工作中...')
        time.sleep(0.2)
def func_b():
    for i in range(10):
        print('学习中...')
        time.sleep(0.2)
if __name__ == '__main__':
    thread1=threading.Thread(target=func_a,daemon=True)
    thread2 = threading.Thread(target=func_b)
    thread1.start()
    thread2.start()
    time.sleep(1)
    print('主进程工作完成')
    
# 2 设置守护主线程  
thread1.setDaemon(True)

# 3 线程对象信息
info=threading.current_thread()
print(info)

# 4 验证多线程之间共享全局变量
my_list=[]
def func_a():
    for i in range(10):
        my_list.append(i)
        print('add:',i)
        time.sleep(0.2)
    print(my_list)
def func_b():
    print(my_list)

if __name__ == '__main__':
    #创建子线程
    thread1=threading.Thread(target=func_a)
    thread2=threading.Thread(target=func_b)
    thread1.start()
    thread1.join(timeout=10)   #等待本线程执行完毕，可以设置超时时间
    thread2.start()

• 同步/互斥

# 1 互斥锁的使用
mutex=threading.Lock()  #获取一个锁  【在主进程中】
mutex.acquire()   #在子线程中上锁       
mutex.release()   #在子线程中解锁     

3.2函数进阶

3.2.1函数参数

函数名实际上存放的是函数的地址

# 1 例子1
def func01():
    print("func01 is shwo")

print(func01)
func02=func01
func02()  #【func01 is shwo】

# 2 例子2
def func01():
    print("func01 is shwo")
def fun(func):
    func()
fun(func01)   #【func01 is shwo】

3.2.2闭包

函数内部的局部变量，在函数运行完后，就被销毁了。但有时候，我们需要保存，函数执行过程中的局部变量。

定义：

1. 在函数嵌套前提下，
2. 内部函数使用了外部函数的变量，
3. 并且外部函数返回了内部函数

我们把这个使用外部函数变量的内部函数称为闭包

# 1 闭包例子
def func_out(num1):  #【创建函数闭包】
    def func_inner(num2):
        num=num1+num2
        print('num:',num)
    # func_inner就是闭包
    return func_inner
f=func_out(10)  #f是闭包实例，是一个闭包  【函数闭包实例化】
f(20)
f(30)   #可以看到10使用了多次

# 2 闭包的使用
	'''
        张三：到北京了么？
        李四：到北京了
        张三：北京冬天冷么？
        李四：冷！
	'''
def func_out(name):
    def func_inner(info):
        print(f'{name}:{info}')
    return func_inner
ZhangSan=func_out("张三")
LiSi=func_out("李四")
ZhangSan("到北京了么？")
LiSi("到北京了")
ZhangSan("北京冬天冷么？")
LiSi("冷！")

# 3 闭包可以修改外部变量   nonlocal
def func_out(num1):
    def func_inner(num2):
        nonlocal num1     #【声明外部函数变量】
        num1=num2+10
        print('num1:',num1)
    print(num1)
    func_inner(20)
    print(num1)
    return func_inner

f=func_out(10)

3.2.3装饰器

在不改变函数源代码的情况下，给函数增加新的功能

封闭开放原则：源代码不修改，但是可以根据实际扩展需求（框架设计）

装饰器的本质是闭包

• 装饰器基础（无参数）

# 1 例子1
def comment():
    print("发表评论")
def check(fn):   #【定义一个装饰器】
    def inner():  #【增加新功能】
        print("请登录")  
        fn()    #【不要忘记原有的功能】【此时inner就变为了一个既有新功能又有原功能的函数（还是原函数）】
    return inner
comment=check(comment)   #用装饰器装饰一下函数 【即增加新的功能】
comment()

# 2 例子2  使用语法糖写法
def check(fn):   #【定义一个装饰器】
    def inner():
        print("请登录")
        fn()
    return inner

@check   #comment=check(comment)
def comment():
    print("发表评论")
comment()
#【通过本例子读者应受到启发，可以把一些固定不变的语法放到装饰器中，然后我们只需要写不同的内容函数，然后用该装饰器装饰一下即可。】

# 3 装饰器的使用，统计函数的执行时间
import time
def get_time(func):
    def inner():
        start=time.time()
        func()
        print("程序执行时间为：",time.time()-start)
    return inner

@get_time
def func():
    for i in range(100000):
        print(i)
func()  #装饰后，执行该函数的时候执行完会打印函数的执行时间

• 通用装饰器

# 1 装饰有参数的函数（一般参数）
def logging(func):
    def inner(a,b):  #inner内部参数和被装饰函数的参数一样多
        func(a,b)   #被装饰的函数
    return inner
@logging
def sum_sum(a,b):
    print(a+b)
sum_sum(1,2)
#【显然这么做泛用性大大降低了，不同的原始函数可能有不同的参数，仅仅一个装饰器无法胜任】

# 2 装饰带有返回值的函数
def logging(func):
    def inner(a,b):
        result=func(a,b)     #装饰器获取原函数的返回值
        return result        #装饰器把原函数的返回值返回
    return inner
@logging
def sum_sum(a,b):
    return a+b
print(sum_sum(1,2))

# 3 通用装饰器（任何参数和返回值）
def logging(func):       
    def inner(*args,**kwargs):
        #新功能增加
        result=func(*args,**kwargs)
        return result
    return inner
@logging
def sum_sum(*args,**kwargs):
    print(args,kwargs)
sum_sum(1,2,2,3,5,6,age='20',name='asdf')

• 多个装饰器装饰一个函数

谁距离原函数近，先装饰谁

# 1 多个装饰器例子
def checkuser(func):
    def inner(*args,**kwargs):
        print("登录验证")
        result=func(*args,**kwargs)
        return result
    return inner

def checkinfo(func):
    def inner(*args,**kwargs):
        print("审核通过...")
        result=func(*args,**kwargs)
        return result
    return inner
@checkuser
@checkinfo
def comment():
    print("发表评论")

comment()

• 带有参数的装饰器

使用装饰器装饰函数的时候可以传入指定参数，注意此时的参数是装饰器的参数而不是函数的参数

# 1 例子1
def logging(flag):          #在装饰器外面添加一个接受参数的函数，然后把真正的装饰函数返回
    def decorator(func):
        def inner(num1,num2):
            if flag=='+':
                print("正在计算假发")
            elif flag=='-':
                print("正在计算剑法")
            result=func(num1,num2)
            return result
        return inner
    return decorator

@logging('+')
def add(a,b):
    result=a+b
    return result

print(add(1,4))

• 类装饰器（使用情况很少）

# 1 例子
class Check(object):
    def __init__(self,fn):   
        self.__fn=fn

    def __call__(self,*args,**kwargs):
        print("登录")
        self.__fn()
@Check    #【comment=Check(comment)->实际上创建了一个类的实例，comment()就调用该实例的call方法】
def comment():
    print('发表评论')
comment()

3.3高级语法

3.3.1property属性

负责把类中的方法当作属性去使用

获取私有属性的方法可以当作属性去使用（装饰器方式，类属性方式）

• 用法，一般把私有属性设置为property属性，这样形式上私有属性可以作为普通属性使用，但实际是受到保护的私有属性。

• 装饰器方式

# 1 快速访问私有属性
class Person(object):
    def __init__(self):
        self.__age=0
    @property       #【property属性，该属性的名字和下面方法的名字一样】 
    def age(self):
        return self.__age
p=Person()
print(p.age)

# 2 修改property属性
class Person(object):
    def __init__(self):
        self.__age=0
    @property       #【property属性】
    def age(self):
        return self.__age
    @age.setter
    def age(self,new_age):
        self.__age=new_age
p=Person()
p.age=100
print(p.age)
#【实际上property属性的名字就是被装饰的函数的名字，设置的时候也要用该函数的名字去设置属性】
#【这就产生了一个有趣的现象。我们定义一个私有属性age，却在设置property属性的时候把函数命定义为agee，那么我们的实例化对象要通过 对象名.agee来获得私有属性age。是不是很奇怪！】
#【继续，我们想要修改私有属性age设置的时候，要用property属性的名字.setter设置 因此我们增加装饰器@agee.setter,但我们却把被装饰的修改函数的名字写成了age。那么神奇的事情发生了！，我们需要用agee来获取私有属性age，但是修改的时候却要用age来修改！！】
#【因此我们规定，property属性一定要设置成和要获取的属性相同的名字，修改该属性的时候也要用相同的名字】

• 类属性方式

# 1 类属性方法设置属性为property属性
class Person(object):
    def __init__(self):
        self.__age=0
    def get_age(self):
        return self.__age
    def set_age(self,new_age):
        self.__age=new_age

    age=property(get_age,set_age) #【注意这里参数的顺序是先get在set，并且传入的是函数名】
p=Person()
p.age=100
print(p.age)

3.3.2with语句和上下文管理器

• with语句

简单安全的使用

自动关闭文件，异常的时候关闭文件

with在调用方法的时候会先调用上文方法, with语句结束后 或者发生异常 再调用下文方法

# 1 with语句操作文件
with open('test.txt',"r") as f:
    file_data=f.read()
    print(file_data)

• 上下文管理器

管理某些操作所需要的前提操作，和必要的后续操作

• 定义上下文管理器

类中由enter和exit方法的对象，就是上下文管理器

with修饰可以在使用方法的时候执行上文方法,并且自动执行下文方法

open方法是一个上下文管理器,因此with修饰后才可以做到自动关闭文件

# 1 上下文管理器 【模拟实现open（）方法，上下文管理器】
class File(object):

    def __init__(self,file_name,file_model):
        self.file_name=file_name
        self.file_model=file_model

    def __enter__(self):
        print("进入上文方法")
        self.file=open(self.file_name,self.file_model)
        return self.file
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("进入下文方法")
        self.file.close()

with File("test.txt","r") as f:
    print(f.read())

3.3.3生成器的创建方式

根据设计者指定的规则，循环生成数据，当条件不在成立时，不再生成数据

数据不是一次性全部生成出来的，而是使用一个再生成一个，可以节约大量 【内存】

• 生成器的使用场景介绍，

比如我们使用列表推导式生成了100个数据，t1时间我们需要10个，此时由100个数据，t2时间我们需要20个此时有20个数据，t3时间我们需要100个，此时有100个数据。如果我们可以根据使用的情况自动生成相应的数据，t1有10个,t2的时候再生成10个，t3的时候再生成80个，这样是不是就节省空间了？

【注意： 获取的值只能顺序获取 无法做到随机取值】

# 1 生成器推导式创建推导式
my_list=(i for i in range(100))
next(my_list)  #next(生成器名字)获取一个数据【按照顺序一个一个获取】

# 2 yield关键字 在函数内部生成数据
def mygenerater(n):
    for i in range(n):
        print('开始生成...')
        yield i  #【暂停（状态保存）并且把i返回】【下次启动时在暂停位置重新开始】
        print('完成一次')  
    #【for循环在生成完后会自动抛出异常，处理异常】
for i in mygenerater(10)
	print(i)   #【for循环 这种方法在使用完后不会产生异常】
    
    
# 3 实例，生成斐波那契数列
def fb(num):
    a=0
    b=1
    #记录生成了几个数字
    index=0
    while index<num :
        result=a
        a,b=b,a+b   #a是当前位置上的数，b是下个位置的数
        index +=1
        yield result

for i in fb(10):
    print(i)

3.3.4深拷贝和浅拷贝

• 浅拷贝

copy函数是浅拷贝，只对可变类型的第一层对象进行拷贝

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hywPMTY4-1681201977314)(python基础和第三方库.assets/image-20230411152124866.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xavALWQl-1681201977315)(python基础和第三方库.assets/image-20230411152401580.png)]

# 1 浅拷贝例子
import copy
a=[1,2,3]
b=[11,22,33]
c=[a,b]
d=c
e=copy.copy(c)
print(id(d))
print(id(c))
print(id(e))
#【可以看到 dc一样e和他们不一样】
print(id(a))
print(id(d[0]))
print(id(c[0]))
print(id(e[0]))
#【可以看到全都一样，也就是说内层数据都是指向同一块空间的】

# 2 浅拷贝不可变数据类型 直接引用，不会开辟新的空间

• 深拷贝

拷贝，所有都拷贝

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1VcXyCwW-1681201977316)(python基础和第三方库.assets/image-20230411153415683.png)]

# 1 深拷贝例子
import copy
a=[1,2,3]
b=[11,22,33]
c=[a,b]
e=copy.deepcopy(c)
print(id(c[0]))
print(id(e[0]))
#【上面的结果是不同的】

# 1 深拷贝 不可变类型 同浅拷贝一样，不开辟任何空间，是一个引用

3.4正则表达式

基于文本规则的代码

0\d{2}-\d{8}这是一个正则表达式，匹配的是一个以0开头加两个数字加一个-再加8个数字的字符串 例如012-12345678

• python中使用正则表达式

# 1 re模块
import re
result = re.match(正则表达式，要匹配的字符串)   #【匹配到是一个结果，没匹配到是None】
result.group()  #获取匹配好的字符串

• re匹配单个字符

代码	功能
.	匹配任意一个字符
【】	匹配【】中的字符
\d	数字
\D	匹配非数字
\s	匹配空格 tab键
\S	匹配非空白
\w	匹配非特殊字符 a-z A-z 0-9 _ 汉字
\W	匹配特殊字符 *±/！，。

import re

result = re.match("itcast.", 'itcast1')    
result = re.match("itcast[1234abcd]", 'itcasty')  #【注意[]中没有逗号】
result = re.match("itcast[0-9]", 'itcasty')  #【匹配0-9】
info = result.group()
print(info)

• 匹配多个字符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Gv95dIq0-1681201977317)(python基础和第三方库.assets/image-20230411155659760.png)]

• 匹配开头和结尾

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IXxZRkP9-1681201977318)(python基础和第三方库.assets/image-20230411155957464.png)]

result = re.match("^\d*\w*", '1324adsfdsa')   #【以任意多个数字为开头，之后跟着任意多个常规符号】
result = re.match("^\d*\w*\d$", '1324adsfdsa')  #【必须以数字为结尾，\d$】
result = re.match("^d.*[^4]$", '1324adsfdsa')  #【必须以数字为结尾，\d$】

• ⭐匹配分组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DnHmABHd-1681201977318)(python基础和第三方库.assets/image-20230411160824715.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PdHSZymm-1681201977319)(python基础和第三方库.assets/image-20230411160923962.png)]

# 1 【匹配多个确定的序列】 
import re
fruit=["apple",'banana',"orange","pear"]
for i in fruit:
    result = re.match("apple|pear|orange", i)  
    if result:
        info = result.group()
        print(info)
        
# 2 【|多与（）一起用在（）中选择】
result = re.match("[a-zA-Z0-9_]{4,20}@(163|qq|126).com", "[email protected]")  
if result:
    info = result.group()
    print(info)
    
# 3 
result = re.match("(qq):([1-9]\d{4,11})", "qq:12345")  
if result:
    info = result.group(1)  #【group中的参数代表的是第几个分组 ，分组从1开始】
    info = result.group(2)
    print(info)

# 4 
result = re.match("<([a-zA-Z1-6]{3,4})>(.*)()", "hh")  #【注意\\1】
if result:
    info = result.group()
    print(info)

# 5  【多分组】
result = re.match("<([a-zA-Z1-6]{4})><([a-zA-Z1-6]{2})>.*", "
hh
")  
if result:
    info = result.group()
    print(info)

# 6 【分组别名】 
result = re.match("<(?P[a-zA-Z1-6]{4})><(?P
[a-zA-Z1-6]{2})>.*", "
hh
")
if result:
    info = result.group()
    print(info)

第三方库

数据分析三大件NPM

Numpy

数值计算库，里面有一些自己的数据结构

import numpy as np

• np相关数据的属性

t1=np.array(list)
t1.dtyp  #求属性，t1的类型
t1.shape    #属性，形状  是一个元组
t1.T

数组相关

• 创建

#创建一个数组
t1=np.array(list1)
t2=np.array(range(n))
t3=np.arange(10)   #和range类似，自动生成0到9之间的np.array类型的数组

#创建全为0/1的数组
t1=np.zeros((a,b))  #创建a行b列的一个全为0的数组
t1=np.ones((a,b))  #创建a行b列的一个全为1的数组

#创建一个主对角线全为1的方阵
t1=np.eye(3)  #3X3的

• 数组类型

#数据类型
t4=np.array(range(n),dtype='int64')  #dtype指定数据的类型
t4.astype("float32")  #astype()是调整数据类型

• 保留几位小数

#数据精度操作
t5=np.array([random.random() for i in range(10)])  #生成一些小数
t6=np.round(t5,2)  #t6为t5中每个数字取两位小数后的结果

• 数组维数相关

# 1 二维数组，以2行为例子
t4=np.array([list1,list2])
# 2 三维数组
(a,b,c)  #a表示数据块数，b，c表示每块里面的二维行列数
# 3 修改形状  注意reshape不会改变原数组
t1.reshape((3,4))  #改成3行四列的二维数组 【不修改元数据】
# 4 展开
t1.flatten() #【不修改元数据】

• 数组相关计算

t1=np.array(list)
# 1 数组加一个数
t2=t1+5   #t1中每个数据都＋5  同理-*/也一样
t2=t1/0   #? 结果是一个同为数组，由nan和inf组成，nan表示不是一个数，inf表示无穷 其中0/0=nan  非0/0=inf

# 2 两个同维度数组计算
t2=t1+t1  #两个数组形状相同  对应位置相加—*/同理 

#3 n*m-1*m /n*m-n*1   【结果是n*m中每行的列都减去1*m中对应列的元素/后者同理。同理-*/也一样】

# 4 数组的布尔运算
t1<10   #得到的是同纬度数据，每个数据小于10为true大于10为false

# 5 数组的转置
t1.T  #这是一个属性，【不改变原来的数据】

• 数组的分割（索引和切片）和组合

# 1 取数组中一个数或者某行某列
t1=np.array(list)
t2=t1[1][1]  #取一行一列的数据，注意行列从0开始排序  【结果是np.int类型或者np.float类型】
t2=t1[1,1]  #【和第三行代码结果相同】
t2=t1[1]  #t1的一行  【是一维数组】
 
# 2 取多行或者多列   【返回的是二维数组】
t1[2:5,0:2]  #（连续）2到5行，0到2列数据
t1[[1,2,5],0:2]  #（离散）1，2，5行的0到2列数据  

# 3 取不连续的一些点的数据 【返回的是一维数组】
t1[[1,3,4],[1,5,4]]  #取（1，2），（3，5），（4，4）列这三个数据

# 4 bool索引
t1[t1>10]   #找到数据小于10的数 【返回一个一维数组】

# 5 数组的拼接
np.vstack((t1,t2))  #竖直拼接，同列数
np.hstack((t1,t2))  #水平拼接，同行数

# 6 条件取值
temp[条件]  #取条件成立情况下的值

• 数值的修改

# 1 首先通过索引切片找到要修改的数据，然后修改即可

# 2 条件修改
t1[t1<10]=1  #修改数组中比10小的数字为1

# 3 三目运算符修改
np.where(t1<=10,0,10)  #t1中小于等于10的为0 其他的为10  【会修改原数据】

# 4 clip裁剪操作
t1.clip(10,18)  #小于10的替换成10，大于18的替换成18

# 5 nan赋值
t1[2,3]=np.nan  #t1的(2,3)数据修改为nan

# 6 交换数组的某行某列
t[[1,2]:]=t[[2,1],:]  #t交换一行一列  【会修改原数据】

• 数组的copy和view

# 1 numpy的引用
a=b #是一个引用，互相影响但不会创建新的对象
# 2 copy
a=b.copy()  #复制一份
# 3 view
a=b[:]   #试图操作，会创建新的对象a，a与b的数据变化是一致的

numpy里一些函数

# 1 最值函数
np.argmax(t,axix=0)  #求0轴方向上的最大值的index，即求每一列的最大值索引【返回的是一个一维数组】
np.argmin(t,axis=1)
np.max()
t.max()   #求最大值
t.min()

# 2 生成随机数
np.random.rand(2,3)  #随机生成2行3列的数组 【取值为0-1，符合均匀分布】【float】
np.random.randn(2,3)  #随机生成2行3列的数组 【取值为0-1，符合正太分布，均值为0，方差为1】【float】

np.random.randint(low,high,(a,b))  #随机生成a行b列的数组 【取值为low-high，符合均匀分布】【int】
np.random.nuiform(low,high,(a,b))  #随机生成a行b列的数组 【取值为low-high，符合均匀分布】【float】
np.random.normal(loc,scale,(a,b))  #随机生成a行b列的数组 【取值为low-high，符合正太分布,均值为loc，方差为scale】【float】

np.random.seed(10)  #确定随机数种子之后每次生成的随机数一模一样，再程序测试阶段使用        

# 3 求两个数组中不相同元素的个数
np.count_nonzero()  #求数组里面不为零的数的个数
np.count_nonzero(t1!=t2)  #求t1中对应位置元素和t2相同的个数 【同维度，t1如果不等于t1就为1】  

#下列统计函数无论使用np.  还是数组名.都可以
# 4 求和函数
np.sum(t1)  #求所有元素的和
t.sum()
np.sum(t3,axis=0)   #所有列相加的结果【返回一个一维数组】

np.mean()  #平均值
np.median()  #中位数
np.ptp()  #极值
np.std()  #标准差

Nan 与 Inf

• nan与inf都是float
• nan和任何元素运算都为nan

# 1 nan是不相等的
# 2 判断nan的个数
np.count_nonzero(t!=t)
np.isnan(t2)   #如果是nan则为true

轴的概念

后续对数组的各种操作都建立在轴上

shape(a,b,c) a是0轴 b是1轴 c是2轴 不同维度的数据轴的排列是不一样的

二维数组 行方向是0轴，列方向是1轴

三维数组 块方向是0轴，行方向是1轴，列方向是2轴

Pandas

基于numpy实现的更具类

可以处理数值之外的而数据,包括字符串,时间序列等

#属性Series
dtype  #对象属性，返回对象里面数据的类型
index  #索引
values  #values   【返回的是一个数组】
ndim   #数据维度

pandas(Series)

# 1 数据类型
Series    #一维带标签的数组  值得就是索引
DataFrame  #二维  Series容器

# 2 指定索引  【关于索引，如果传入的是字典，a，a和索引能对应起来的则取值，如果索引里面有a里面没有取NAN，如果a里面有索引里面没有则忽略该值】
pd.Series([1,2,3,4],index='abcd')

# 3 通过字典创建Series
dic={
    'a':1,
    'b':2,
    'c':3,
}
a=pd.Series(dic)

# 4 修改数据类型
a.astype(float)  #同numpy操作类似

# 5 取值  
a['a']  #索引来取
a[0]   #位置取值
a[[1,2,3,4]]
a[:3]
a[['a','b','c']]   #如果没有这个索引取到的是nan
t[t>4]    

# 6 to_list
a.to_list   #把Series转换为列表

读取文件

# 1 读取csv
df=pd.read_csv('filepath')  #【结果是一个FrameDate类型数据】

panda(DateFrame)

有一个index索引行索引，和一个columns列索引，代表的是列属性 默认从0开始增加

# 1 创建DateFrame 
pd.DataFrame(np.arrange(12).reshape(3,4)，index=list('abc'),columns=list('ABCD'))   #【接收的参数是一个二维数组】

# 2 根据字典/列表创建DateFrame
a={
    'name':['1','2'],
    'age':[18,20],
    'tel':[100,120]
}  
b=[{'name':'1','age':18,'tel':100},{'name':'2','age':20,'tel':120}]
pd.DateFrame(a)   #【注意字典的格式,values是列表】
pd.DateFrame(b)   #【注意列表的格式，元素是字典】

# 3 数据显示方法
df.head(5)    #头部5行
df.tail(5)  #尾部5行
df.info()   #相关信息，行列数，非空值个数，列类型，内存占用
df.describe()  #统计结果：计数，均值，标准差等等等  【只有数值列才可以计算】

# 4 排序方法
dp.sort_values(by='列名'，ascending=False) #根据某一列排序  #ascending默认为true递增排序

# 5 取值
df['列名']  #取具体某一列   【返回值是Series】
df[0]['列名']  #取某个数据
df[:20]  #取前20行
df.iloc[:20,:20]   #和其他数据类型的取行列效果一样【注意要用iloc方法来取】  【通过位置获取】
df.loc[['a','b'],['A','B']]  #和iloc效果类似      【通过行列索引名字取值】
df.loc['a':'f',['w','z']]   #连续取行，【注意af都被选中】

# 6 布尔索引
df[df['a']>800]  #取df的a列中大于800的数据
df[(df['a']>800)&(df['a']<1000)]   #多个索引条件需要用&链接

# 7 DateFrame里面的字符串
da['A'].str.len()   #求da的A列里面的每个元素的len【注意要用str.len()才能让len作用到每一行】

# 8 数据插入
data.insert(0,'ones',1,axis=1)数据插入，插入到第零列，起名字为ones，用1填充

数据缺失处理

# 1 判断nan
pd.iana(df)
pd.notna(df)
df.isna()  #返回的结果都是布尔类型

# 2 删除nan
df.dropna(axis=0)  #找到nan按照行删除
df.dropna(axis=0,how='all')  #找到nan按照行删除  【只有某行全部为nan才删除】
df.dropna(axis=0,how='all',inplace=True)  #【原地修改该变量】

# 3 填充nan
df.fillna(100)  #填充100给nan
df.fillna(df.mean())  #自动根据某列的平均值来帮助我们填充该列nan

统计方法和字符串离散化(案例)

• 统计方法

# ！！注意，DateFrame利用统计方法默认是作用与每一列

# 1 把某列变成一个列表，其中每个元素只出现依次
df['Director'].unique()   #【输出是一个列表】

# 2 列表里面还是列表 转换为一个单列表
a=np.array([1,2,3],[4,5,6])
b=a.flatten()  #【1,2,3,4,5,6】
a=[[1,2,3],[4,5]]  #列表里面的列表长度不相同
b=[i for j in a for i in j]  #【1，2，3，4，5】

# 3 统计方法  可以获取某一列后进行统计计算
df['列明'].mean()
df['列明'].min()
df['列明'].median()
df['列明'].argmax()

• 字符串离散化案例

# 1 案例 
temp_list=df['Category'].str.split(',').tolist()  #先把Category里面的每个电影的类型字符串分割，然后合并成一个[[],[],[]]
category_list=(list(set([i for j in temp_list for i in j])))   #把一个[[],[],[]]=>[] 并且通过set去重
zeros_list=pd.DataFrame(np.zeros((df.shape[0],len(temp_list))),columns=temp_list)  #创建一个全为0的数组，行为数据的行，列为所有类型的列
#给每个电影出现分类的位置复制为1
for i in range(df.shape[0]):
    zeros_list.loc[i,temp_list[i]]=1  

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8I5wvM9u-1681201977319)(python基础和第三方库.assets/image-20230408145034374.png)]

数据合并和分组聚合

• 数据合并

# 1 水平拼接 （左右拼接）
t1.join(t2)  #以t1的行为基准，没有的数据用nan 

# 2 条件合并  （左右合并）
t1.merge(t2,on='a')  #笛卡尔积操作，但是只有t1,t2中a列数据相同的行进行笛卡尔积

• 数据分组聚合

# 1 分组 【按照某一列的不同值进行】【分组后的结果实际上就是index和values】
group=df.groupby(by='列名')   
for i,j in group:
    print(i,j)  #i是该列的值，j是该列为i值的DataFrame对象
    
# 2 聚合方法
group.count()  #统计按照某列分组后，不同的分组中其他列包含多少条数据
group.mean()    #统计按照某列分组后，不同的分组中其他列数据的平均值

# 3 对多列进行分类，并且只求分类后数据某一列的count值
group=df['Brand'].groupby(by=[df['country'],df['province']])
print(group)
group=df[['Brand']].groupby(by=[df['country'],df['province']])  #两个[[]]结果是DateFrame

• 关于索引

# 1 以某列数据作为索引
df.set_index('列名',drop=False)  #【drop=False该列不会被删除，不会改变df原来的索引】
df.set_index(['列名1','列名2'])  #【多索引】

#注意Series可以直接用ad['索引名字']来取值，但是DateFrame需要用ad.loc['索引名字']来取值

时间序列

# 1 生成一段时间范围
pd.data_range(start=None,end=None,Periods=None,freq='D')  #periods代表生成几个时间
pd.date_range(start='20171230',end='20180131',freq='10D')  #生成一段时间，按照10天间隔十个昵称

# 2 把字符串转化为格式化时间类型
pd.to_datetime('字符串',format='')  #format告诉程序用什么样的程序进行格式化操作

# 3 时间重采样
t.resample('M').mean()  #t是一个时间类型，按照月份进行重采样 并且求平均值

# 4 时间格式化
t.strftime("%Y-%m-%d")  #t是一个时间格式的变量，strftime进行时间格式化

matplotlib

数据画图工具

散点图，直方图，柱状图

可以去官网查看不同的图形代码样例，改一下就可以

#修改matplotlib字体 
matplotlib.rc()  

折线图

plot()绘制折线图

• 简单绘制折线图

from matplotlib import pyplot as plt  #导入包
x=range(2,26,2)   #折线图x轴
y=[15,13,14,17,20,25,26,26,24,22,18,15]   #折线图y轴
plt.plot(x,y)
plt.show()
#其中xy轴的刻度是根据给定的数据自动生成的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rzwle70y-1681201977319)(python基础和第三方库.assets/image-20230405105404192.png)]

• 完善X轴刻度显示

import matplotlib.pyplot as plt
#画图前修改图片大小dpi等属性信息
plt.figure(figsize=(20,8),dpi=80)  
#数据配置
x=range(2,26,2)   
y=[15,13,14,17,20,25,26,26,24,22,18,15]   
#绘图
plt.plot(x,y)

# ！！设置x轴相关
#设置x轴的刻度  
plt.xticks(x)   #用x列表里面的值设置x轴的刻度
plt.yticks(range(min(y)-2,max(y)+2))
#设置x轴的刻度为字符串
plt.xticks(x,_str)  #x和_str一一对应，不显示x里面的值，而是显示对应的在_str里面的值 注意x与_str中的元素个数要相同
#旋转90度 ratationx轴标记旋转90度
plt.xticks(x,_str,rotation=90)
#设置X轴字体为中文
my_front = font_manager.FontProperties(fname="字体路径")
plt.xticks(_x,_str,fontproperties=my_front)

#保存图片，可以保存为svg或者png
plt.savefig("./t1.svg")
plt.show()

• 添加总体描述信息，x轴y轴以及图的含义

plt.xlabel("时间")
plt.ylabel("温度")
plt.title("时间温度情况")

• 网格线

plt.grid(alpha=0.4)  #根据x轴和y轴的刻度绘制网格 alpha为透明度

• 多个曲线如何区别（添加图例）

#为曲线添加名字
plt.plot(x1,y1,label='a')
plt.plot(x2,y2,label='b')

#添加标签，即曲线名字  如果要使用中文 关键字为prop
plt.legend(prop=my_font)

#显示在左上角
plt.legend(prop=my_font,loc="upper left")

• 自己设置线条颜色形状

#橙色和虚线，点表示  #color也可以用16进制颜色代码，记得前面加#
plt.plot(x,y,label='self',color='orange',linestyle=':')
plt.plot(x,y,label='self',color='orange',linestyle='--')

#设置网格形状
plt.grid(alpha=0.4,linesytle='--')

绘制散点图

#plt.scatter()绘制即可，其他的描述语言和折线图一样
plt.scatter(x,y)   #xy是列表

绘制条形图

#plt.bar()
plt.bar(x,y,width=0.3)    #xy是列表  width修改条状图的宽度
#横着绘制   
plt.barh(x,y,height)       #注意这里的xy不变，x还是自变量，y还是因变量 但是在后面plt.xtick的时候因为x轴和y轴反转了，因此需要修改

#绘制多个条形图
#和其他图形多次绘制相同，不过需要注意的是不同图形的x轴要偏移一点
import matplotlib.pyplot as plt

x=['test1','test2','test3','test4','test5']
y1=[203,231,45,73,123]
y2=[123,55,62,724,212]
y3=[123,356,21,41,612]

width=0.2
x1=[i for i in range(5)]
x2=[i+width for i in range(5)]
x3=[i+ width*2 for i in range(5)]
plt.bar(x1,y1,width=width,label='x1')
plt.bar(x2,y2,width=width,label='x2')
plt.bar(x3,y3,width=width,label='x3')
plt.legend()
plt.xticks(x2,x)
plt.xlabel('X')
plt.ylabel('Y',rotation=90)
plt.title('test')
plt.show()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-akY6jikQ-1681201977320)(python基础和第三方库.assets/image-20230406102609010.png)]

绘制直方图

和条形图的区别就是 x轴连续

import matplotlib.pyplot as plt
import random
#随机300个数，求从0到100步长为10之间的数的个数，比如0-10之间的个数，10-20之间的个数 其中区间是[a,b)
y1=[random.randint(0,100) for i in range(300)
x1=[i for i in range(0,101,10)]
plt.hist(y1,x1) #其中y1是原始数据，x1是我们设置的值，该直方图用于统计y1中落在x1中相邻两个数之间的个数
plt.xticks(x1)
plt.grid()
plt.show()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jbAUJ2jy-1681201977326)(python基础和第三方库.assets/image-20230406110009373.png)]

⭐其他图形

matplotlib其他图形网站

http://matplotlib.org/gallery/index.html

关于前端交互式绘图可以参考如下网站，通过numpy和pandas把数据处理好传送过去即可

Apache ECharts

plotly 画图界的GitHub

https://plot.ly/python/

其他常用库

random

#随机数x   a<=x<=b
random.ranint(a,b)
abs()  #绝对值函数
round()  #四舍五入函数

conda相关命令

• conda install [package name]

• conda activate [环境名]

• conda deactivate #退出虚拟环境

pandas/numpy/matlib

读文件数据处理相关

data = pd.read_csv('ex1data1.txt',names=['population','profit'])
第一个参数是文件名，并且在当前文件目录下，第二个参数names给文件的列起名字  返回值是dataframe类型

data.head()
data.tail()    打印出data的后几行

data.describe() #数据信息统计

data.info() #数据结构信息

reg=np.insert(reg,0,values=0,axis=0)在第零行插入一个值values 行插入用axis=0 reg为被插入的数据
 
data.iloc[:,0:-1]数据切片 默认有逗号隔开，从0列开始一直到倒数第一列之前的（不包括倒数第一列）

np.array(x) 把dataframele类型转换为数组类型（矩阵）

X.shape 看看x是什么样的矩阵

Y.reshape(n,m)把y重塑成N x M型的矩阵

X@Y 矩阵乘法

X*Y 矩阵点乘，表示矩阵对应元素相乘，型不变
np.zeros((2,1))初始化一个2行一列的矩阵，默认值为0

cost.append(cos) cost数组后面添加一个元素cos

x=np.linspace(0,25,100) 生成一个以为列表 最小值为0最大值为25 一共100个数

acc=np.mean(y_pre==Y)  y_pre==y为1否则为零，之后求平均值

映射函数，把线性映射到非线性 其中power是最大的次数

def feature_mapping(x1,x2,power):
    data ={}   #定义一个字典用来存储映射后的数据
    for i in np.arange(power+1):
        for j in np.arange(i+1):
            data['F{}{}'.format(i-j,j)]=np.power(x1,i-j)*np.power(x2,j)
    
    return pd.DataFrame(data)  #把字典变成dataframe类型的数据

tpye(data)    data的类型
data['X']  获取X值的字典

绘图相关

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IGasSrPB-1681201977326)(C:\Users\顾子茵\AppData\Roaming\Typora\typora-user-images\image-20230228144924039.png)]

fig,ax=plt.subplots(a,b)  绘图实例ax其中有a X b个图，无参默认一个图

ax.plot(a,b,label='') 绘制曲线图，横坐标数为a，纵坐标数为b其中a b都是一维数组 label 表示绘制的该条曲线的标签


ax.scatter(a,b,label='') 散点图，其中 a,b为列表
plt.scatter(X[:,0],X[:,1],c=Y.flatten(),cmap='jet')   #根据Y值的不同绘制颜色不同的点
ax.legend()  如label无法显示出来就加上一句

ax.set(xlable='',ylabel='',title='')x轴的名字 y轴的名字 图的名字

ax.scatter(data[data['accepted']==0]['exam1'],data[data['accepted']==0]['exam2'],c='r',marker='x',label='y=0')
#data[data[iaccepted]==0]['exam1']取出data中所有accepted==0的exam1列数据为x轴数据，同理为y轴数据，marker='x' 用x表示该点

等高线画法

登高线图画法

x=np.linspace(-1.2,1.2,200)##均匀分布的数组，-1.2到1.2之间
xx,yy=np.meshgrid(x,x)  生成与x行 与y列对应 的二维矩阵
z=feature_mapping(xx.ravel(),yy.ravel(),6).values   xx.ravel()把二维矩阵变成向量    xx.flatten()表示把行向量或者列向量变成一维数组的形式。

zz=z@theta_final
zz=zz.reshape(xx.shape)  

plt.contour(xx,yy,zz,0)    话等高线，其中0表示只画出zz为0的等高线

决策边界

def plot_boundary(model):
    x_min,x_max=-0.5,4.5
    y_min,y_max=1.3,5
    xx,yy=np.meshgrid(np.linspace(x_min,x_max,500),np.linspace(y_min,y_max,500))
    z=model.predict(np.c_[xx.flatten(),yy.flatten()])
    
    zz=z.reshape(xx.shape)
    plt.contour(xx,yy,zz)

svm包

svc1=SVC(C=1,kernel='linear/rbf', gamma=gamma)   #获取一个svc模型实例，传入相应的c值选择对应的核函数gamma是和函数里的方差
svc1.fit(X,Y.flatten())  #x是矩阵，返回一个一维数组，比如吧n行1列的列向量变成一个一维数组
svc1.predict(X)  #输入矩阵后输出对应的预测结果
svc1.score(X,Y.flatten)   #获取该模型的精确度

ray

ray.get 获取到的值为（array([]),2,3,‘stirng’)时如何获取array或者string

以上述例子
result=ray.get(work1_id)[1]   结果是2
result=ray.get(work1_id)[3]   结果是string

string

# 1 返回第n个字母 从a到z
a=string.ascii_uppercase[5]  #【返回第五个字母大写的E】