【Python全栈_公开课学习记录】_python search是个变量-CSDN博客

本文链接：https://blog.csdn.net/fly_with_bb/article/details/134172678

一、初识python

(一).Python起源

Python创始人为吉多·范罗苏姆（荷兰），Python崇尚优美、清晰、简明的编辑风格。Python语言结构清晰简单、数据库丰富、运行成熟稳定，科学计算统计分析领先。目前广泛应用于云计算、Web开发、科学运算、人工智能、系统运维、金融领域。在金融领域中，主要用于量化分析、金融分析尤其擅长策略回测。机缘巧合通过视频课程学习Python，向金融+Python方向靠拢。

Python是一门解释性语言。区别于输出结果型，通过及时输出，提高开发效率。

（二）.python的基本知识

1.python变量的命名规则

(1).python变量由字母、数字、下划线组成

(2). python变量不能用纯数字，也不能用数字开头

(3). python变量不能是python的关键字

2.python变量命名的常用规范

(1). 变量名不要太长

(2).变量名要有意义

(3)变量名区分大小写

(4).变量名不要用中文

(5).多使用驼峰体和下划线命名

3.python变量类型

(1).int类型，整数，可以进行+、-*、/、%(计算余数)、//（整除）运算

（2).str类型，字符串，',",'''。可以通过type（变量）查看数据类型,字符串可以进行+ *运算

（3).bool类型，真命题或假命题，结果True、False，只用来条件判断

（4).用户交互，使用input（），input接收到的为字符串

4.python基本数据类型

（1). int整数

#bit_length()返回一个数的二进制长度

（2）str字符串

由',",'''括起来的内容是字符串，字符串是不可改变的数据类型，不论执行任何操作，原字符串是不会改变的，每次操作都会返回字符串。

a.字符串的索引和切片

索引从0开始，使用[下标]

切片[起始位置:结束位置] #切片时顾头不顾尾，只能切到开头的位置，切不到结尾，默认从左往右切

print（s[-1:-3:-1]）"-1"表示步长，每位移一单位，从右往左切片

b.字符串的修改

sn=s.capitalize() 把字符串首字母变成大写

sn=s.upper() 把字符串变成大写

sn=s.lower() 把字符串变成小写

sn=s.swapcase() 把字符串大小写互换

sn=s.title() 把字符串每个单词首字母变成大写

sn=s.center(x,"*or空白等") 把字符串左右两边用*拼接成x个单位

sn=s.strip() 默认去掉空格，空白，可以指定去掉的内容 (去掉左侧空格：s.lstrip 去掉右侧空格：s.rstrip)

sn=s.erplace("old","new") 把字符串中的内容进行替换

sn=s.split() 对字符串进行切割，切完的结果是一个列表 #与 joint相对

c.字符串的查找

sn=s.startwith() 字符串是否以xxx开头

sn=s.endwith() 字符串是否以xxx结尾

sn=s.count(a) 字符串中a出现的次数

sn=s.find(a) 查找字符串中a第一次出现的位置，没有返回-1

sn=s.inde(a) 查找字符串中a的位置，没有会报错

d.字符串的条件判断

s.isdigit() 判断是否为数字

s.isalpha() 判断是否为字母

s.isalnum() 判断是否为数字

e.字符串长度

len(s) 字符串中字符的个数 #python内置函数

（3）bool布尔值

布尔值只有两个值，True,False,空的东西是False,非空的是True

（4）list列表

a.什么是列表

列表是一个可变的数据类型，列表由[]表示，每一项元素用逗号隔开，列表什么都能装，能装对象的对象，列表可以装大量的数据

b.列表的索引和切片

列表和字符串一样，也有索引和切片，切片切出的内容是列表，索引的下标从0开始，[起始位置:结束位置:步长]

c.列表的增删改查

增加：lst.append() 在原有列表基础上进行的操作，屁股后面添加，只能加一个

lst.insert(n,xxx) 在第n个位置插入xxx

lst.extend(["",""]) 元素为列表整体添加，否则迭代添加

删除：lst.pop(n) 删除指定位置元素

lst.remove("") 删除特定元素

del lst[:] 切片删除

lst.clear() 清空

修改：lst[n]="xxx" 修改第n个元素为xxx

lst[m:n]=lst["x"] 切片部分修改为x

查询：for el in lst:

print(el)

d.列表的相关操作

计数：lst.count("") 列表中某个元素的个数

排序：lst.sort() 将列表正序排列

括号中加"reverse=True"变为降序排列

翻转：lst.reverse() 将列表中的元素翻转

嵌套：lst[][] 可进行降维操作

lst="_"join(["",""])将列表转换成字符串,每个元素之间用_连接

split字符串切割为列表

（5）tuple元组

元组tu用（）表示，元组中如果只有一个元素，需要在括号中加入一个逗号，Tu=tuple()为空元组，元组是一个可迭代对象，可以使用for循环。

元组不可以进行增删改，只能看，可以查询，切片。

元组查询：tu[]，tu[m:n]

元组第一层元素不能进行赋值，内部元素是没有要求的

（6）dict字典

a.字典的含义

字典dict用{}表示，字典为键值对数据，{key:value},具有唯一性特点

字典中的键都必须是可hash的，不可变的任何数据类型都可以当做字典中的键，字典中的值没有任何限制。

b.字典的增删改查

增加：dic[key]=value

dic.setdefault(key,value) 如果字典中不存在就进行添加，存在不做任何操作

删除：dic.pop("key")

del dic["key"]

修改：dic[key]=value 修改字典键对应的值

dic.update(字典)

查找：dic(key) 没有会报错

dic.get(key) 没有返回none

set.default(key)

c.字典的其他操作：

dic.keys 获取到的键存在一个高仿列表中

dic.values 获取到的值存在一个高仿列表中

dic.items 获取到的所有键值对元组形式存在一个高仿列表中

dic.fromkeys 不会对字典产生影响，fromkeys直接使用类名进行访问

列表和字典在循环的时候不能直接删除，需要把要删除的内容记录在新列表中，然后循环新列表进行删除。

（7）set集合

a.set集合定义：

set集合是Python的一个基本数据类型，一般不是很常用，set中的元素是不重复的，无序的，里面的元素必须是可hash的（int,str,tuple,bool）,可以这样来记，set就是dict类型的数据，但是不保存value，只保存key，set也用{ }表示。

#set中的元素是可hash的，set本身不可hash.

集合去重

b.set集合的增删改查

增加：s.add

s.update 迭代更新

删除: s.pop # 随机弹出一个

s.remove(“xxx”) #直接删除元素元素不存在会报错

clear() 清空集合，打印出来是set（）与dict区分

修改：

Set集合中的数据没有索引，也没有办法定位一个元素，所以没有办法直接修改，可以采用先删除后添加的方式完成修改操作

c.set集合的常用操作

查询：for 循环

交集：print（s1 & s2）

并集: print(s1 | s2)

差集：print(s1 - s2)

子集：print（s1 <s2）

5.深浅拷贝

lst2 = lst1 # 赋值

没有创建新对象，共用同一对象。

lst2 = lst1[:] #浅拷贝

只拷贝第一层内容： [:],copy()

深拷贝：把对象内部的内容全部拷贝一份，引入copy模块。

import copy

lst2 = copy.deepcopy(lst1)

6.文件操作

（1）初识文件操作

使用python读写文件是非常简单的操作，可以使用open（）函数打开一个文件，获取到文件句柄，然后通过文件句柄就可以进行各种操作了，根据打开方式的不同能够执行的操作会有响应的差异。

文件操作的函数：

open（文件名（路径），mode=""，encoding=""）

文件路径

绝对路径：从磁盘的根目录寻找或者从互联网上寻找一个路径。

相对路径：相对于当前程序所在的文件夹，../上一次文件夹。

（2）打开文件的方式：

r,w,a,r+,w+,a+,rb,wb,ab,r+b,w+b,a+b；默认使用的是r（只读）模式。

r模式

读取文件

for line in f: #逐行读取

print(line)

w模式

带w，只要操作，就会清空源文件。

如果没有文件，会自动创建文件。

a模式

写的时候，换行需要手动控制，/n

f = open("hhh",mode="a",encoding="UTF-8")

b模式

rb、wb、ab、bytes如果处理非文本文件，不能写encoding

r+模式

不论读取了多少内容，光标在哪儿，写入的时候都是在结尾写入，除非开始就写入是在开头。

最好的读写同时存在的模式。

w+模式

写度会清空内容，写完之后光标在最后，读取是没有内容的。使用seek（0）移动光标到开头。

a+模式

追加不会清空，光标在最后，移动光标到开头。

（3）常用的操作

光标（seek）

seek(3) #在开头移动3个byte

seek（0）#开头

seek（0，2）#末尾

tell（） #光标位置

truncate（） #从文件开头截断到光标位置，删除光标后面所有内容。

(4)修改文件

引入os模块

打开目录文件

打开文件副本

从源文件中读取内容进行修改，写入到副本

删除源文件

重命名副本

7.函数

（1）函数

函数是对功能的封装

语法：

def 函数名（）：

函数体

调用：

函数名（）

（2）返回值

如果函数什么都不写，不写return，没有返回值，得到的是none。

在函数中间或者末尾写return，返回none。

在函数中写return值，返回一个值。

在函数中可以返回多个返回值，return 值1，值2，值3...,接受的是元组。

（3）参数

函数执行的时候给函数传递信息

在函数声明的位置的变量：形参

在函数调用的地方给的具体的值：实参

把实参的值交给形参的过程：传参

实参：

位置参数，按照形参的参数位置，给形参传值

关键字参数，按照形参的名字给形参传值

混合参数，既用位置参数，也用关键字参数，先位置，后关键字

形参：

位置参数

默认值参数

动态参数

*args，表示接受位置参数的动态传参，接受到的是元组。

顺序：位置参数>*args>默认值参数>**kwargs

**args，关键字的动态传参

（5）打散和聚合

形参：聚合

实参：打散

func(*lst) 打散，把list，tupple，set，str进行迭代打散

聚合成关键字参数：

def func(**kwargs):

print(kwargs)

打散成关键字参数：

dic = {'a':'1','b':'2'}

func(**dic)

（6）函数的注释：

（7）命名空间

在python解释器开始执行之后，会在内存中开辟一个空间，每当遇到一个变量的时候，就把变量名和值之间的关系记录下来，但是当遇到函数定义的时候，解释器只是把函数名读入内存，表示这个函数存在了，至于函数内部的变量和逻辑，解释器是不关心的。函数只是加载进来，只有当函数被调用和访问的时候，解释器才会根据函数内部声明的变量来进行开辟变量的内部空间，随着函数执行完毕，这些函数内部变量占用的空间也会随着函数执行完毕而被清空。

我们给存放名字和值的关系的空间起名叫：命名空间。变量在存储的时候就是存储在这片空间中。

命名空间分类：

1.全局命名空间：直接在python文件中，函数外声明的变量都属于全局命名空间

2.局部命名空间：在函数声明的变量会放在局部命名空间

3.内置命名空间：存放python解释器提供的名字，list,tupple,str,int,这些都是内置命名空间。

加载顺序：内置命名空间-全局命名空间-局部命名空间（函数被执行的时候）

取值顺序：局部命名空间-全局命名空间-内置命名空间

作用域:作用域就是作用范围，按照生效范围分为全局作用域和局部作用域

全局作用域：包含内置命名空间和全局命名空间。在整个文件的任何位置都可以使用。（从上到下逐行执行）

局部作用域：在函数内部可以使用。

可以通过globals（）函数查看全局作用域中的内容，也可以通过locals（）查看当前局部作用域中的变量和函数信息。

（8）global和nonlocal

global：在局部访问全局中的内容

nonlocal：在局部寻找外层函数中最近的变量

（9）函数名的应用

函数名的命名规范和变量是一样的，函数名就是变量名。

函数名可以作为列表中的元素进行存储。

def func1():

pass

def func2():

pass

lst = [func1，func2]

for el in lst:

el()

函数名可以作为参数传递给函数：

def func():

pass

def proxy(fn):

fn

proxy(func)

函数名可以作为函数的返回值：

def func():

def inner():

pass

return inner #返回内存地址

（10）闭包

闭包：在内层函数中访问外层函数的变量

闭包的作用：

1.可以保护变量不受侵害

2.可以让一个变量常驻内存

判断是否是是闭包：

def func():

a=10

def inner()

print(a)

print(inner.__closure__) #如果打印none，不是闭包；如果不是none，是闭包。

8.迭代器

用来遍历列表、字符、元组... 可迭代对象。

dir（），查看xx类型的数据可以执行哪些方法。

iterable，其中带__iter__，可以使用for循环，为可迭代对象。

iterator，迭代器里有__iter__,还有__next__。

dir（int）

dir(str)

迭代器的特点：

节省内存

惰性机制

不能反复，只能向下执行

9.生成器

函数中如果有yield，这个函数就是生成器函数，生成器函数（），获取的是生成器，这个时候不执行函数。

yield：相当于return，可以返回数据，但是yield不会彻底中断函数，分段执行函数。

gen.__next__()，执行函数，执行到下一个yield。

def func():

print("")

yield 1 #返回数据

gen = func() #不会执行函数，拿到的是生成器

send（），和__next__()一样，可以执行下一个yield，可以给上一个yield位置传值。

send 和 __next__（）区别：

send 和 __next__()都是让生成器向下走一次

send可以给上一个yield的位置传递值，不能给最后一个yield发送值。在第一次执行生成器代码的时候不能使用send（）。

10.推导式

推导式：用一句话生成一个列表。

语法：[结果 for 循环条件筛选]

列表推导式

lst = [i for i in range(100) if i%2==1]

print(lst)

字典推导式：{k:v for 循环条件筛选}

lst = [11,22,33,44]

dic = { i:lst[i] for i in range(lst)}

print(dic)

生成器表达式：

（结果 for循环条件）

特点：

惰性机制

只能向前

节省内存

11.内置函数

作用域：globals，locals

迭代器：iter，next，range

其他：

输入输出：input，print

内存相关：id，hash （目的是为了存储，计算之后是一个数字，拿空间换时间）

文件相关：open

模块相关：import

帮助：help

调用相关：callable #是否可以被调用执行

查看内置属性：dir

字符串类型执行代码函数：eval（动态执行代码片段，还原回字典、列表），exec（执行），compile（编译）

基础数据类型相关：

数字相关：

数据类型：bool，int，float，complex

进值转换：bin 二进制

oct 八进制

hex 十六进制

数学运算：abs 绝对值

divmod 计算商和余数

round 四舍五入

pow 求次幂，第三个参数取余

sum 求和

min 最小值

max 最大值

数据结构相关：

列表和元组：list，tupple

序列相关内置函数：reversed（翻转），slice（切片）

字符串：str，format（格式化），bytes，bytearry，memoryview，ord（查看编码位置），chr（输入位置数字找出对应字符），ascii，repr（原样输出字符串）。

数据集合：dict，set，frozenset

数据相关内置函数：len，sorted，enumerate，all，any，zip，fiter，map

匿名函数：lambda（）

匿名函数(单行函数)，语法：lambda 参数：返回值

a = lanbdan : n*n

ret = a(9)

print(ret)

排序函数：sorted（）

sorted（）

list = ['西游记'，‘水浒传’，‘三国演义’，‘红楼梦’]

def func（s）

return len（s）

n = sorted(lst, key=func)

print(n)



#key:排序方案，sorted函数内部会把可迭代对象中的每一个元素拿出来交给key，后面的key计算出数字，作为当前元素的权重，整个函数根据权重进行排序。

过滤函数：filter（）

lst = ['唐三藏'，‘孙悟空’，’猪八戒‘，’沙悟净‘]

def func(el):

if el[0] == ’猪‘

return False #不想要的元素

else：

return Ture #想要的元素

f = filter(func,lst) #将lst中每一项传递给func，所有返回Ture的都会被保留，返回False的过滤

f = filter(lambda el:el[0] 1= '猪'，list)

for e in f：

print（e）

映射函数：map（）

map（func，lst）把后面可迭代对象的每个元素传递给function，结果就是function的返回值。

分而治之思想

map（func，map（func，map（func，lst）））

递归函数：

自己调用自己。

递归深度，可以自己调用自己的次数，最大1000。

遍历文件夹：打印所有文件和普通文件的文件名

import os

def func(filepath,n):

# 打开文件夹

files = os.listdir(filepath)

# 拿每一个文件名

for file in files:

#获取文件路径

file_path = os.path.join(filepath,file)

判断是否是文件夹

if os.path.isdir(file_path)：

# 如果是文件夹，继续再来一遍

print（"\t"*n,file,":"） #打印文件名

func(file_path,n+1)

else： #不是文件夹，普通文件

print("\t"*n,file)

func("d:/",0)

二分法：

二分法可以在有序排列中，通过不断对半切割数据，提高数据查找效率。

lst = [1,4,6,7,45,66,345,767,788,999]

n = 66

left = 0

right = len(lst)-1

while left < right: #边界，当右边比左边还小的时候退出循环

        mid = (left + right)//2 #必须是整数，索引没有小数

        if lst[mid] > n:

                right = mid - 1

        if lst[mid] < n:

                left = mid +1

        if lst[mid] == n:

                print("找到这个数")

        break

        else:

                print（"没有这个数"）

递归二分法

lst = [11, 23, 45, 67, 99]

def func(n,left,right):

        if left <= right:

                mid = (left +right)//2

                if n > lst[mid]:

                        left = mid +1

                        func(n,left,right) #递归递归入口

                if n < lst[mid]:

                        right = mid -1

                        func(n,left,right)

                if n == lst[mid]:

                         print("找到了这个数")

                else：

                        print("没有这个数") #递归的出口

12.常用模块

re模块

查找：

findall: 匹配所有，每一项都是列表中的一个元素

ret=re.findall('\d+','sasff454feaf') #正则表达式，待匹配的字符串

print(ret)

search: 只匹配从左到右第一个，得到的不是直接的结果，而是一个变量，通过变量的group方法获取结果。如果没有匹配到，会返回none，使用group会报错。

ret = re.search('\d+','sdfsadga654fhhd656')

print(ret) #内存地址，这是一个正则匹配的结果

print(ret.group()) #通过ret.group()获取真正的结果

防止报错

ret=re.search('\d+','dsdaasfgds')

if ret:

print(ret.group())

match: 从头开始匹配，相当于search中的正则表达式加上^

字符串处理的扩展：替换、切割

split: 切割返回列表，按照正则规则切割，默认匹配到的内容会被切掉

s = 'alex43bob4434david4'

ret = re.split('\d+',s)

print(ret)

sub: 替换 #对象、旧的、新的、替换次数，按照规则寻找要被替换掉的内容

re.sub('\d+', 'H', 'alex4354bob43david4',1)

print(ret)

subn: 返回一个元组，第二个元素是替换的次数

re模块的进阶：时间/空间

compile 节省使用正则表达式解决问题的时间，编译正则表达式为字节码，在多次使用的过程中，不会多次编译。用正则表达式进行findall，search...能够节省时间

ret = re.compile('\d+')

print(ret)

res = ret.findall('alex24bob4352david42')

finditer 返回一个迭代器，所有的结果都在迭代器中，需要通过循环+迭代器的形式取值，能节省使用正则表达式解决问题的空间

ret = re.finditer('\d+','alex42bob8878david99')

for i in ret:

print(i.group())

正则表达式：参考书《正则指引》

普通字符就表示一个正常的字符，元字符表示特殊的意义，如果转义元字符，那么这个元字符就失去了特殊意义。

几个字符的组合关系：

字符/元字符：只约束一个字符

字符+量词：约束一个字符连续出现的次数

字符+量词+？：约束一个字符连续出现量词范围内的最少次数

字符+量词+？+x：约束一个字符连续出现量词范围内的最少次数，遇到x立即停止

元字符：\d, \w, \s, \n, \t, \b, \W, \D, \S . ^$ [] [^] | ()

量词：? + * {n} {n,} {n,m}

贪婪匹配:默认贪婪匹配

分组在模块中的应用：

search中分组：

import re

s = <a>wahaha</a> #标签语言

ret = re.search('<(\w+)>(\w+)</(\w+)>',s)

print(ret.group(0)) #显示所有

print(ret.group(1)) #显示第一个分组

print(ret.group(2)) #显示第二个分组

print(ret.group(3)) #显示第三个分组

分组命名：（?p<这个分组的名字> 正则表达式）

random模块

获取随机小数

获取随机整数

从一个列表中随机抽取值

sample不会取到重复值。

打乱一个列表的顺序:在原列表的基础上进行修改，节省空间

time模块

time模块主要和时间相关

time.sleep() #程序走到这等待2s钟

时间格式：

时间戳：时间戳表示的是1970年1月1日00:00:00开始按秒计算的偏移量，运行type(time.time()) ,返回float浮点数类型。

格式化时间字符串：2023-01-01

print(time.strftime('%Y-%m-%d %H-%M-%S'))

print(time.strftime(%y-%m-%d %H-%M-%S))

print(time.strftime('%c')) #国外时间格式

结构化时间（元组）：

time.localtime()

三种时间格式的转换：

时间戳时间转换成字符串时间：

字符串时间转换成时间戳：

sys模块：

和python解释器打交道

sys.argv #argv 的第一个参数，是python这个命令后面的值

当在命令行执行python文件，不是pycharm中，这些需要输入的参数不需要在程序中以input的形式输入了。

sys.path #模块存在硬盘上，使用的时候才在内存中。一个模块能否顺利导入，看sys.path下面有无这个模块所在。

sys.modules #是我们导入内存中的所有模块的名字：这个模块的内存地址

os模块：

和操作系统交互的模块。

序列化模块：

将列表、字典等其他内容转换成字符串和bytes的过程就是序列化。

序列化的目的：

以某种存储形式使自定义对象持久化

将对象从一个地方传递到另一地方

使程序更具维护性

json模块：

dumps,loads 在内存中做数据转换

json.dumps() 序列化

json.loads() 反序列化

json 在所有的语言之间都通用

json 能处理的数据类型是有限的：字符串列表字典数字

字典中的key只能是字符串

在文件中记录字典：

在文件中读取字典:

dump, load可以直接操作文件

dic = {'key1':'value','key2':'value2'}

with open('json_file','a') as f:

json.dump(dic,f)

with open('json_file','r') as f:

dic = json.load(f)

print(dic.keys())

pickle模块：

支持python中几乎所有的数据类型

序列化的结果只能是字节

只能在python中使用

和文件操作的时候需要用rb，wb模式打开

可以多次dump和load