Python自学笔记整理

最新推荐文章于 2024-08-08 20:55:36 发布
最新推荐文章于 2024-08-08 20:55:36 发布
阅读量203 收藏
点赞数
分类专栏： 基础知识 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44120790/article/details/112972907
版权

**python自学**

杂记

1-4python基本类型

文件操作：
txt=open(’./文件名’）
./表示当前代码文件夹中的文件
t=txt.read()
l=txt.readlines() list类型
txt.close()必须关文件

txt=open(’./文件名’，‘w’）覆盖
txt=open(’./文件名’，‘a’）追加
txt.write(‘内容’)
txt.close()关文件

不用写关文件
with open(’./文件名’） as f:
f.write()
***1.type()查看数据类型 ***

type(2/2)
<class 'float'>
type(2//2)
<class 'int'>

2.进制
二进制：0b10 十进制：2
八进制:0o11 十进制：9
十六进制:0x10 十进制：16
转化为二进制：bin()
转化为十进制：int()
转化为十六进制：hex()
转化为八进制：oct()
3.基本数据类型
Number:数字
bool类型 bool(0)或空 bool(’ ')或bool([])或bool(None)==false
complex类型：36j

str字符串 多行
单引号，双引号(英文，成对出现）
例：中间引号作为文字出现
“let’s go”
‘let"s go’
‘let\‘s go’ 反斜杠\ 转义
例：三引号定义多行字符串，换行输入
‘’’
aaaa
aaaa
aaaa
‘’’
输出：’\naaaa\naaaa\naaaa\n’
例：print()
print(‘aaa\naaa\naaa’)
输出：
aaa
aaa
aaa
例：换行输入
‘aaa\
ddd’

转义字符
\n换行
\r回车 这俩不一样**
\'单引号
\t横向制表符

原始字符串 r
防止字符串中\当做转义字符：print(r’xxx\xxx’)
注意print(r’xxx’\xxx’)会报错，r后面引号不成对不是字符串，也无法转为原始字符串
字符串运算
字符串拼接：“ssss”+“aaaa”； “aaa”*3是重复三次输出；两个字符串相乘是错误的
获取单个字符：“abcde”[0]取第一个字符’a’；“abcde”[-2]取倒数第二个字符‘d’

4组
4.1列表定义list：[]
[1,2,3]，[“ddd”,“cc”,1,true,[2,4]]任意组合其他类型
4.2列表基本操作：
访问（类似字符串操作）：
[“a”,“c”,4,5,“rr”][0]访问“a”
[“a”,“c”,4,5,“rr”][0:2]访问[‘a’,‘c’]
[“a”,“c”,4,5,“rr”][-1:]访问[‘rr’]
修改列表（类似字符串操作）：
列表相加合并，相乘错误；可以乘一个常数
[[‘a’,‘b’,‘c’],[],[],[]]

将a内容复制到b

a=[1,2]
b=a[:]
b

4.3元组tuple()
(1,‘1’,true)[0]
(1,‘1’,true)[0:2]
(1,2,3,4,5)[0:4:2]//[初始位置：最后位置：步长]
(1,2,3)+(‘a’,‘b’)
(1,2)*2
例：
type((1,2,3))----tuple
type((1))---------int 只有一个元素，默认（）做运算
定义只有一个元素的元组（a,）-----type((a,))
定义没有元素的元组（）

4.4总结
序列：String（字符串）List（列表）Tuple（元组）
共有操作：1.序列[序号]：获取元素；[0:2]类似获取切片
2. +，*
3.例：3 in [1,2,3]-----true || 3 not in [1,2,3]------false
len([1,2,3]), max(), min()///ASCII编码ord()最大最小

4.5set集合{}
无序即不支持切片;不重复;4.4.3支持
例：求差集{1,2,3,4,5}-{1,2}----------{3,4,5}
求交集{1,2,3,4,5}&{1,2}---------------{1,2}
求并集{1,2,3,4,5}|{2,7}----------{1,2,3,4,5,7}
定义空集合：set()

4.6dict字典:{key1:value1,key2:value2}
不能有相同的键值；
value:str,int,float,dict,set,list;
key:不可变类型int,float,str,元组(数值改变，内存地址不变)
空字典表示：{}
{‘K’:‘1’;‘E’:‘2’}[‘K’]--------‘1’

4.7总结

5变量与运算符

5.1
变量不能用数字开头
系统关键字不能用在变量名里面：and;if;import等 保留关键字
区分大小写
5.2引用
在这里插入图片描述
如上图：
int值类型：a->1，b->1，a->3不可变类型（str，元组）
list引用类型：可变类型（set,dict）

如下图：str类型不可变
在这里插入图片描述
5.3元组与list
list可以用append()追加元素
元组不可变类型，不可用append()追加元素，定义完成后不可改变

多维元组：类似多维数组访问
例：a=(1,2,3,[(7,8),5,6])
a[3][0][1]
8
此时元组内列表内的值可改变

运算符：算数，赋值，
5.4
赋值运算符：算数符=

比较运算符：返回bool值
、int(true)=1，数值可以与Bool类型加减-------b+=b>=1

逻辑运算符：and且 or或 not非
、0，空均为false
、例：‘0’-----true
、and返回结果：and比较两个数，必须检查完两个数再确定返回值
、例：3 and 1-------1
、or返回结果：or比较两个数，若检查前一个可以确定结果则返回前一个
、例：3 or 9-------3

成员运算符:in、 not in 返回bool类型
dict成员{key:value}}运算针对key

身份运算符：is、not is
is 比较内存地址id()，==比较值
集合无序
例：
a={1,2,3}
b={2,1,3}
a==b--------True
a is b--------False
元组有序
例：
a=(1,2)
b=(2,1)
a==b-----------False

类型判断 isinstance( , )
第二个参数可写成元组

对象三个特征：id地址，value值，type
is, == , isinstance()
详见
l菜鸟教程Python3运算符

6分支循环条件枚举

6分支循环条件枚举
表达式是运算符和操作数所构成序列
6.1表达式优先级
not>and > or 逻辑运算优先级最低
但有=用右结合：c=1 or 2-----------c=1
(not a) or ((b+2)==c)
位运算：~按位取反；^按位异或；|按位或；&按位与

缩进区分代码块
#单行注释
…
多行注释
…

if 条件 ：
'四个空格’print（）
else :
'四个空格’print（）
不能混淆压缩（会删除空格）

ACCOUNT='aaa'
PASSWORD='123'
#python中没有常量，python程序一般通过约定俗成的变量名全大写的形式表示这是一个常量
user_account=input()
user_password=input()

if(ACCOUNT==user_accoun and PASSWORD==user_password)
    print('成功')

注意：

  1. 关于python中常量的定义：.

2.每一个模块都在文件开头要有注释，模块文档
3.逻辑运算符左右有空格
4.可设置tab在IDE中为四个空格
5.pycharm技巧
a.print按tab-------print(a)
snippet
tab
6.pass:占位语句
7.封装思想

elif代码简洁；没有switch

7.循环

7.1while循环

while n<10 :
    n+=1
    print(n)
else:
    print('结束')

7.2for循环

a=[['a','s','d'],(1,2,3)]
for x in a:
    for y in x:
        print (y,end='')#默认end='\n'
else:
    pass

a=[1,2,3]
for x in a:
    if x==2:
        continue#输出1,3
    print(x)	

a=[1,2,3]
for x in a:
    if x==2:
        break
    print(x)
else:
    print('EOF')
    #break跳出for循环不会执行else，只输出1
    #continue会执行else

a=[['a','s','d'],(1,2,3)]
for x in a:
    for y in x:
        if y=='s':
            break;
        print (y,end='')#默认end='\n'
else:
     print('EOF')
     #break跳出内层for循环，最后输出：'a' 1,2,3,EOF

#0~9输出
for x in range(0,10):
#range(起始，偏移量，步长)
    print(x)
    #b=a[0:len(a):步长]

三种组织结构：包；模块；类
函数变量：不是组织结构
命名空间：包名.模块名
_init_.py标注一个包，_init_.py会自动执行

1.导入模块：
import 模块名（.py）
引用：模块名.变量名
或import 模块名 as 简化名
2.导入具体变量
from 模块名 import (变量名,变量名)或星号*
#括号换行
#控制星号导入范围：在被引入模块中写__all__=[‘变量名’]
from 包 import 模块名

_init_.py作用：
1.批量import：若包下面的每个模块需大量导入系统类库，则直接在另一个包_init_.py内导入，其他模块只需import 另一个包名
2.控制被导入包下面被导入的模块
3.当一个包被导入则其_init_.py会自动执行

T:不能几个.py文件互相循环导入，

8.函数

8.1
round(操作数,保留小数点后几位数)
T:快速了解内置函数：打开python交互命令行>>help(内置函数名称)
8.2函数结构
def 函数名称(参数列表 可以没有):
没有return会打印出None
T1：设置最大递归次数

import sys
sys.setrecursionlimit(100000)

8.3返回多个参数
return a1,a2,a3
#默认组装成元组
T:如何获取呢？
用有意义的变量名称接收,而不是元组索引方式：
名称1,名称2=函数名称(a1,a2)

8.4序列解包

a=1
b=2
a,b=1,2
#解包
d=1,2,3#元组序列
print(type(d))
a,b,c=d

8.5参数
1必须参数，
2关键字参数：不用考虑函数参数传入顺序，

def add(x,y)
    result =x+y
    return result

c=add(y=1,x=2)  
#关键字参数，增加可读性

3默认参数
若需传入参数很多

def add(x,y=3,z=2):
	print(x,y,z)

add(x=2,y=2)

T:必须参数必须在默认参数前面
必须按照顺序或者指定关键参数

9面向对象

class 类的名字不建议用下划线():
实例化不用加new
类的基本作用：封装

class Student():
	name=''
	age=0
	#行为--所做操作方法；特征
	def print_file(self):#与在模块下不同，就算不用传参在参数中加self（this）
		print('name:' + self.name)
		print('age'+ str(self.age))
s=Student()#不推荐在类内部调用类
s.print_file()

方法：设计层面
函数：运行过程

class Student():
	name=''
	age=0
	#行为--所做操作方法；特征
	def __init__(self):#构造函数
	#实例化时自动调用
	#构造函数内部初始化对象的特征
		print('s')
		#只能返回None
	def do_home(self):
		print('hw')
		
#class Printer();	#设计优化，打印并不合适student的行为
#	def print_file(self):#与在模块下不同，就算不用传参在参数中加self
#		print('name:' + self.name)
#		print('age'+ str(self.age))
s=Student()
	#不推荐在类内部调用类
s.print_file()
#查看构造函数特性
a=s.__init__()
print(a)
print(type(a))#nonetype

9.1变量–类变量和实例变量
类：将数据以及数据操作封装在一起
类实例化变成对象
构造函数

class Student():
	name=''
	age=0#类变量
	#行为--所做操作方法；特征
	def __init__(self,name,age):#构造函数
	#实例化时自动调用
	#构造函数内部初始化对象的特征
		print('s')
		#左变量=右参数
		name=name
		age=age
		#只能返回None
	def do_home(self):
		print('hw')
		
#class Printer();	#设计优化，打印并不合适student的行为
#	def print_file(self):#与在模块下不同，就算不用传参在参数中加self
#		print('name:' + self.name)
#		print('age'+ str(self.age))
s=Student('姓名',12)
	#不推荐在类内部调用类
	#自动执行构造函数，实例化应与构造函数传入参数保持一致
print(s.name)#访问对象下的变量name
	#打印为空，因为在构造函数里的赋值并没有改变取值

区别类变量与实例变量

class Student():
	name='空'
	age=0#类变量
	#行为--所做操作方法；特征
	def __init__(self,name,age):#构造函数
	#实例化时自动调用
	#构造函数内部初始化对象的特征
		print('s')
		#左变量=右参数
		self.name=name#self.来保存不同对象特征值--实例变量
		self.age=age
		#只能返回None
	def do_home(self):
		print('hw')
		
#class Printer();	#设计优化，打印并不合适student的行为
#	def print_file(self):#与在模块下不同，就算不用传参在参数中加self
#		print('name:' + self.name)
#		print('age'+ str(self.age))
s=Student('姓名',12)
	#不推荐在类内部调用类
	#自动执行构造函数，实例化应与构造函数传入参数保持一致
print(s.name)#访问对象下的变量name-----姓名
print(Student.name)#--------------------空

class Student():
	#此类作为描述学生抽象整体，不适合将名字与年龄作为类变量
	sum=0#班级学生个数
	#name=''
	#age=0#类变量
	#行为--所做操作方法；特征
	def __init__(self,name,age):#构造函数
	#实例化时自动调用
	#构造函数内部初始化对象的特征
		print('s')
		#左变量=右参数
		self.name=name#self.来保存不同对象特征值--实例变量
		self.age=age#赋值实例变量
		#只能返回None
	def do_home(self):
		print('hw')
		
#class Printer();	#设计优化，打印并不合适student的行为
#	def print_file(self):#与在模块下不同，就算不用传参在参数中加self
#		print('name:' + self.name)
#		print('age'+ str(self.age))
s=Student('姓名',12)
	#不推荐在类内部调用类
	#自动执行构造函数，实例化应与构造函数传入参数保持一致
print(s.name)#访问对象下的变量name-----姓名
print(Student.name)#--------------------空

class Student():
	name='类'
	age=0#类变量
	#行为--所做操作方法；特征
	def __init__(self,name,age):#构造函数
	#实例化时自动调用
	#构造函数内部初始化对象的特征
		print('s')
		#左变量=右参数
		name=name
		age=age
		#只能返回None
	def do_home(self):
		print('hw')
s=Student('姓名',12)
print(s.__dict__)#查看字典，当前对象下所有变量--------此时为空
	#需在函数中加入 self.
	#不推荐在类内部调用类
	#自动执行构造函数，实例化应与构造函数传入参数保持一致
print(s.name)#访问对象下的变量name---------'类'（而不是空）
	#实例变量字典虽为空，但是会再向类变量字典中！寻找！赋值
	#此种查找仅限于在调用时会出现，方法内部不会查找
print(Student.name)#--------------------类

class Student():
	#此类作为描述学生抽象整体，不适合将名字与年龄作为类变量
	sum=0#班级学生个数
	#name=''
	#age=0#类变量
	#行为--所做操作方法；特征
	def __init__(self,name,age):#构造函数
	#！！------实例方法参数中必须有self，调用不用传入self------！！
	#实例方法是实例可以调用的方法
	#实例化时自动调用
	#构造函数内部初始化对象的特征
		print('s')
		#左变量=右参数
		self.name=name#self.来保存不同对象特征值--实例变量
		self.age=age#赋值实例变量
		#只能返回None
	def do_home(self):
		print('hw')
s=Student('姓名',12)
	#不推荐在类内部调用类
	#自动执行构造函数，实例化应与构造函数传入参数保持一致
print(s.name)#访问对象下的变量name-----姓名
#print(Student.name)#--------------------空

class Student():
	#此类作为描述学生抽象整体，不适合将名字与年龄作为类变量
	sum=0#班级学生个数
	#name=''
	#age=0#类变量
	#行为--所做操作方法；特征
	def __init__(self,name1,age):#构造函数
		self.name=name1#self.来保存不同对象特征值--实例变量
		self.age=age#赋值实例变量
		print(self.name)
		#print(name)#!---------不推荐去掉self.-----!

9.2方法–实例方法
实例方法内部访问类变量
构造函数：初始化类的特征，调用时 类名(),访问内部变量：self.变量名

实例方法：描述类的行为，对象调用 方法名()，

方法内部访问类变量：类名.类变量名

class Student():
	#此类作为描述学生抽象整体，不适合将名字与年龄作为类变量
	sum1=0#班级学生个数
	#name=''
	#age=0#类变量
	#行为--所做操作方法；特征
	def __init__(self,name,age):#构造函数
	#实例方法参数中必须有self，调用不用传入self
	#实例方法是实例可以调用的方法
	#实例化时自动调用
	#构造函数内部初始化对象的特征
		#左变量=右参数
		self.name=name#self.来保存不同对象特征值--实例变量
		self.age=age#赋值实例变量
		print(Student.sum1)#!-----方法内部访问类变量！
		#print(self.__class__.sum1)#!-----方法内部访问类变量！
		#只能返回None
	def do_home(self):
		print('hw')
s=Student('姓名',12)
	#不推荐在类内部调用类
	#自动执行构造函数，实例化应与构造函数传入参数保持一致
print(s.name)#访问对象下的变量name-----姓名
print(Student.name)#--------------------空

9.3方法–类方法

class Student():
	#此类作为描述学生抽象整体，不适合将名字与年龄作为类变量
	sum1=0#班级学生个数
	#name=''
	#age=0#类变量
	#行为--所做操作方法；特征
	def __init__(self,name,age):#构造函数
	#实例方法参数中必须有self，调用不用传入self
	#实例方法是实例可以调用的方法
	#实例化时自动调用
	#构造函数内部初始化对象的特征
		#左变量=右参数
		self.name=name#self.来保存不同对象特征值--实例变量
		self.age=age#赋值实例变量
		#实例方法操作类变量
		self.__class__.sum1+=1#!!!!
		print('学生总数为：'+ str(self.__class__sum1))#!!!!
		#print(Student.sum1)#方法内部访问类变量
		#print(self.__class__.sum1)#方法内部访问类变量
		#只能返回None
	def do_home(self):
		print('hw')
		
s1=Student('姓名1',12)#实例化时自动会调用构造函数，
s2=Student('姓名2',12)
s3=Student('姓名3',12)

定义类方法
@classmethod #装饰器
def 方法名(cls):

class Student():
	#此类作为描述学生抽象整体，不适合将名字与年龄作为类变量
	sum1=0#班级学生个数
	#name=''
	#age=0#类变量
	#行为--所做操作方法；特征
	def __init__(self,name,age):#构造函数
	#实例方法参数中必须有self，调用不用传入self
	#实例方法是实例可以调用的方法
	#实例化时自动调用
	#构造函数内部初始化对象的特征
		#左变量=右参数
		self.name=name#self.来保存不同对象特征值--实例变量
		self.age=age#赋值实例变量
		#实例方法操作类变量
		#self.__class__.sum1+=1#!!!!
		#print('学生总数为：'+ str(self.__class__sum1))#!!!!
		#print(Student.sum1)#方法内部访问类变量
		#print(self.__class__.sum1)#方法内部访问类变量
		#只能返回None
	def do_home(self):
		print('hw')
#！！------构造类方法-----！！	
	@classmethod	#装饰器
	def plus_sum(cls):
		cls.sum1+=1
		print(cls.sum)
		
s.Student('姓名',12)
Student.plus_sum()#也可以用s.plus_sum()
s2=Student('姓名2',12)
Student.plus_sum()
s3=Student('姓名3',12)		
Student.plus_sum()```

9.4方法–静态方法
@staticmethod
def 方法名(参数名1，参数名2):
可访问类方法的变量，不可访问其他方法的实例变量

class Student():
	#此类作为描述学生抽象整体，不适合将名字与年龄作为类变量
	sum1=0#班级学生个数
	#name=''
	#age=0#类变量
	#行为--所做操作方法；特征
	def __init__(self,name,age):#构造函数
	#实例方法参数中必须有self，调用不用传入self
	#实例方法是实例可以调用的方法
	#实例化时自动调用
	#构造函数内部初始化对象的特征
		#左变量=右参数
		self.name=name#self.来保存不同对象特征值--实例变量
		self.age=age#赋值实例变量
		#实例方法操作类变量
		#self.__class__.sum1+=1#!!!!
		#print('学生总数为：'+ str(self.__class__sum1))#
		#print(Student.sum1)#方法内部访问类变量
		#print(self.__class__.sum1)#方法内部访问类变量
		#只能返回None
	def do_home(self):
		print('hw')
#构造类方法	
	@classmethod	#装饰器
	def plus_sum(cls):
		#cls.sum1+=1
		#print(cls.sum)
		#print(self.name)#!---类方法不能访问实例变量
#！！-----构造静态方法-----！！
	@staticmethod
	def add(x,y)
		#print(Student.sum1)#!---可访问类变量
		#print('静态')
		#print(self.name)#！---静态方法不能访问实例变量
		
s.Student('姓名',12)
s.add(1,2)
Student.add(1,2)#!-----静态方法可以被类和对象调用----！！
s.plus_sum1()
Student.plus_sum1()

9.5成员可见性
类的不安全
在外部对变量更改，建议通过调用方法更改
或

class Student():
	#此类作为描述学生抽象整体，不适合将名字与年龄作为类变量
	sum1=0#班级学生个数
	#name=''
	#age=0#类变量
	#行为--所做操作方法；特征
	def __init__(self,name,age):#构造函数
		self.name=name#self.来保存不同对象特征值--实例变量
		self.age=age#赋值实例变量
		self.score=0
	def do_home(self):
		print('hw')
		self.do_math()#！！内部调用
	
	def do_math(self):#!!!
		print()
		
	def marking(self,score):
	if score<0:
		score=0
		self.score=score
		print(self.name+'分数：'+str(self.score))
		
#构造类方法	
	@classmethod	#装饰器
	def plus_sum(cls):
		#cls.sum1+=1
		#print(cls.sum)
		#print(self.name)#!---类方法不能访问实例变量
#构造静态方法
	@staticmethod
	def add(x,y)
		#print(Student.sum1)#可访问类变量
		#print('静态')
		#print(self.name)#静态方法不能访问实例变量
		
s.Student('姓名',12)
s.marking(99)#!!!对变量更改应通过方法来完成
#s.score=-1!!不安全,而调用方法可以增加判断非法输入

设置可见性：公开的public，私有的private
私有：__方法名/变量名()
左右双下划线不算私有
外部调用私有方法会报错；
外部调用私有实例变量没有报错：

class Student():
	#此类作为描述学生抽象整体，不适合将名字与年龄作为类变量
	sum1=0#班级学生个数
	#name=''
	#age=0#类变量
	#行为--所做操作方法；特征
	def __init__(self,name,age):#构造函数
		self.name=name#self.来保存不同对象特征值--实例变量
		self.age=age#赋值实例变量
		self.__score=0
		
	def do_home(self):
		print('hw')
		self.do_math()#！！内部调用
	
	def do_math(self):#!!!
		print()
		
	def marking(self,score):
	if score<0:
		score=0
		self.__score=score
		print(self.name+'分数：'+str(self.__score))
		
s.Student('姓名',12)
s.marking(99)
s.__score=-1#!----动态特性给对象s增加新__score，不是 marking方法的私有变量
print(s.score)
print(s.__dict__)#!----查看内部成员列表
s2=Student('姓名2',12)
#print(s2.__score)#!----报错

9.6三大特性：继承性，封装性，多态性
继承性
子类继承父类变量，方法，构造函数

class human():
	sum1=0
	def __init__(self,name,age):
		self.name=name
		self.age=age
	def get_name(self):		
		print(self.name)
	
	def do_homework(self):
		print('父类方法')

super调用父类方法

from 模块名 import human
class Student(human):

	#此类作为描述学生抽象整体，不适合将名字与年龄作为类变量
	#sum1=0#班级学生个数
	#name=''
	#age=0#类变量
	#行为--所做操作方法；特征
	def __init__(self,school,name,age):
		#self._score=0
		#self._class_.sum+=1
		#print(Student.sum1)#!-----方法内部访问类变量！
		#print(self.__class__.sum1)#!-----方法内部访问类变量！
		self.school=school
		#human.__init__(self,name,age)        #（不推荐）调用父类构造函数
		 #此处必须传入self
		 #自己的对象调用实例方法会自动传入self不需要再传入
		 #！！此处是类调用实例方法，当做普通方法调用，传入所有参数包括self
		super(Student,self).__init__(name,age)#（推荐）调用父类构造函数
	def do_homework(self):
		super(Student,self).do_home()#调用父类do_homework()
		print('子类')
		
		
s1=Student('学校','姓名',18)#可继承父类构造函数，但需要传入参数
print(s1.sum1)#对象可继承父类的变量
print(Student.sum1)#子类调用父类变量
print(s1.name)
print(s1.age)
#s1.get_name()#可继承父类方法
s1.do_homework()#对于父子同名方法，优先调用子类方法

10正则表达式与JSON

特殊字符序列

10.1元字符与普通字符
普通字符

import re
a='w|c++|c|php|python'
r=re.findall('python',a)#规则为常量，无意义
print(r)

元字符
\d表示0-9
\D表示非数字
根据需求查找手册记忆，不要全部死记硬背

import re
a='w2c++3c5php6python'
r=re.findall('\d',a)#\d表示0-9，元字符
print(r)

10.2字符集
[ab]字符a,b为或的关系
[^ab]非a或b
[a-d]匹配a到d中间字符

import re
s='abc,acc,adc,aec'
r=re.findall('a[cf]c',s)#找中间字母为c,f的字符串
print(r)

10.3概括字符集
\d表示0-9
\D表示非数字
\w表示字母和数字和下划线，单词字符
\W表示非单词字符
\s匹配空白字符（空格，\t，\n，\r）

10.4数量词
{3,6}3,4,5,6个字符

import re
a='w2c++3c5php6python'
r=re.findall('[a-z]{3,6}',a)#连续匹配3个到6个字符
print(r)

贪婪（[a-z]{3,6}）与非贪婪（[a-z]{3,6}?）

* 匹配0次或无数次
+匹配1次或无数次
?匹配0次或1次

import re
a='pytho1pythonn2python'
r=re.findall('python?',a)
print(r)

10.5边界匹配
^从字符串开始匹配
$从末位匹配

import re
qq=1000009
r=re.findall('^\d{3,8}$',qq}#匹配完整字符串
print(r)

10.6组
[或]
(且）

import re
s='pythonpythonpython'
r=re.findall('(python){3}'.s)

10.7匹配模式
忽略大小写

import re
s='pythonCpython'
r=re.findall('c',s,re.I)
print(r)

. 表示匹配除换行符\n外任意字符
re.S将“\n”当做一个普通的字符

import re
s='pythonC\npython'
r=re.findall('c.{1}',s,re.I|re.s)
#c.{1}匹配c再加上除\n外任意一个字符
#re.findall(匹配，来源，模式1|模式2）
print(r)

10.7re.sub字符串替换

import re
s='pythonCpythonC'
r=re.sub('C','java',s,1)#1表示只替换第一个，默认为0全部替换
print(r)

将函数作为参数传入

import re
s='pythonCpythonC'

def convert(value):
	print(value)
	match1=value.group()
	return '!'+match1
	#
r=re.sub('C',convert,s,1)
print(r)

import re
s='python2python74354'

def convert(value):
	match1=value.group()#读取返回结果
	if int(match1)>=6:
		return '9'#返回字符串类型
	else:
		return '0'
	#数字替换				
r=re.sub('\d',convert,s)
print(r)

10.8re.match和re.serch
只匹配一次
re.match从字符串首字母匹配，不满足则返回空
re.serch搜索字符串，找到第一个满足的结果则返回

10.9group分组

#用search返回hello和python之间字符串

import re

s='hello world hello python'
r=re.search('hello(.*)python',s)#普通字符可定界
#. 表示匹配除换行符\n外任意字符
#* 匹配0次或无数次
print(r.group(1))
#group(0)记录完整匹配结果

用findall 返回hello和python之间字符串

import re

s='hello world hello python'
r=re.findall('hello(.*)python',s)#普通字符可定界
#. 表示匹配除换行符\n外任意字符
#* 匹配0次或无数次
print(r)

import re

s='hello world hello python,oh python'
r=re.search('hello(.*)python(.*)python',s)#普通字符可定界
#. 表示匹配除换行符\n外任意字符
#* 匹配0次或无数次
print(r.group(0,1,2))
#print(r.groups())

10.10
JSON：轻量级的数据交换格式，数据类型
与Javascript区分开
表现形式：字符串
符合格式的字符串叫JSON字符串
跨语言
10.10.1反序列化
JSON object

import json

json_str='{"name":'my',"age":20}'
#Json字符串,用双引号
s=json.loads(json_str)#转化为python
print(type(s))
print(s)-----#dict
print(s['name'])
print(s['age'])

JSON array

import json

json_str='{"name":'my',"age":20,"flag":false},{"name":'my',"age":20}'
#JSON数组
#Json字符串,用双引号
s=json.loads(json_str)#转化为python的数据类型
print(type(s))
print(s)#list

序列化

student=[
			{"name":'my',"age":20,"flag":false},
			{"name":'my',"age":20}
		]
json_s=json.dump(student)	
print(type(json_s))
print(json_s)
YOLO小蜗
关注
专栏目录
python笔记整理
09-21
python笔记整理
python list倒序_Python学习教程：Python入门笔记整理
weixin_40009207的博客
11-21 216
本期的Python教程为大家整理了一些Python学习笔记类！刚入门的伙伴可以看过来了！第一章 Python变量和数据类型1-1 Python中的数据类型一、整数Python可以处理任意大小的整数，当然包括负整数。①普通整数：写法一样，例如：1，100，-8080，0。②十六进制：用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。二、浮点数①普通浮点数：直接用数学写法...
Python学习笔记
最新发布
2301_80968281的博客
08-08 554
可以内含双引号可以内含单引号和多行注释写法一样，同样支持换行操作，使用变量接受它，他就是字符串，反之就是多行注释可以使用转义字符来将引号解除效用，变成普通字符串# 在字符串内包含双引号# 输出结果 hello world "hello world" 'hello world' "hello world" 'hello world'**函数：**是组织好的，可重复使用的，用来实现特定功能的代码段count =0count +=1print(f"字符串。
Python学习笔记整理之输入输出、python eval函数
12-21
总结起来，本篇学习笔记主要涵盖了Python中的变量自动类型推断、`input`和`print`函数的使用、以及`eval`函数的功能和风险。了解这些基本概念对于初学者掌握Python编程至关重要。在实际编程中，应根据需求合理选择...
Python学习笔记整理3之输入输出、python eval函数
12-24
1. python中的变量： python中的变量声明不需要像C++、Java那样指定变量数据类型（int、float等），因为python会自动地根据赋给变量的值确定其类型。如 radius = 20，area = radius * radius * 3.14159 ，python会...
Python3学习笔记整理
12-06
【Python3学习笔记整理】 在Python3的学习过程中，掌握一系列核心概念和技能是至关重要的。这份笔记涵盖了Python的基础语法、数据结构、控制流、函数、模块化编程、面向对象编程等多个方面，旨在帮助初学者系统地...
python核心笔记整理pdf版本
03-12
【Python核心笔记整理PDF版本】是一份详尽的Python学习资料，旨在帮助初学者和有一定经验的开发者深入理解Python这门强大的高级编程语言。Python以其简单易读的语法和广泛的应用领域著称，无论是Web开发、数据分析、...
python 笔记整理
qq_38355352的博客
03-24 505
Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。
Python笔记整理
qq_56413030的博客
09-19 215
print('E:\\nba\\npc')可以给前面加上r例如：print(r'E:\\nba\\npc')加法['aaa','bbb'] + ['cccc'] == ['aaa','bbb','cccc']（除法中分为/，//。乘法:['aaa','bbb']*2=['aaa','bbb','aaa','bbb']“切取方向”，正表示“从左往右”取值，负表示“从右往左”取值。直取到数据“端点”，至于是到“起点”还是到“终点”，同样由。开始取值，至于是从“起点”还是从“终点”开始，则由。
Python_Python笔记整理
Tingshuo2009的博客
06-09 336
1. 基础笔记 1.1 if，else else为子块，不能独立使用 一个if语句中可以包含多个elif语句，但结尾只能有一个else语句 1.2 数据交换 a = 2 b = 4 a, b = b, a print(a) print(b) 1.3 自己定义一个字典（包含姓名，年龄，英语成绩），打印出”我名字是 **, 我今年**岁，英语考了**分 ！" d = {'name':'传智','age':23,'score':98} print("我名字是%s, 我今年%d岁，英语考了%d.
Python学习笔记整理
qiren5210的博客
07-09 297
一、标准数据类型 1、直接赋值： 数字支持int，long，float，complex(复数) #字符串 a = 'abc' #数字 b = 123 字符串的截取 str = 'Hello World!' print str # 输出完整字符串 print str[0] # 输出字符串中的第一个字符 print str[2:5] # 输出字符串中第三个至第六个之间的字符串 print str[2:] # 输出从第三个字符开始的字符串
大学python笔记整理_python 笔记整理
weixin_34061440的博客
02-05 2931
Python isdigit() 方法检测字符串是否只由数字组成。Pythonint() 函数用于将一个字符串或数字转换为整型。判断字符、列表、元组等的长度或项目个数：Python len()。enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。(把下标取出来)python中单引号和双引号使用完全相...
Pythony元组、字典以及函数
qq_25558239的博客
05-24 446
元组：元组与字符串类似，下标索引从0开始，可以进行截取，组合等。访问元组：元组可以使用下标索引来访问元组中的值。修改元组：元组中的元素值是不允许修改的，但我们可以对元组进行连接组合：tup3 = tup1 + tup2;tuple1=tuple(list) :    列表转换为元组。删除元组：元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。元组运算符、函数都与列表相同。字典：...
Python入门笔记整理
iot3000的博客
04-18 417
参考：http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000 1.安装Python 首先，从Python的官方网站python.org下载最新的2.7版本，网速慢的同学请移步国内镜像。 2.安装文本编辑器Sbulime或者pycharm 3.创建一个test.py的文件放到F:盘
Python学习笔记整理与分享
资源摘要信息:"这份资源名为'我的 Python 学习笔记.zip'，从标题可以看出，这是一份关于Python编程语言的学习笔记文档。Python作为一种广泛使用的高级编程语言，以其简洁明了的语法和强大的功能库而受到全球开发者的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值