如有错误还请帮忙告知更改
字符串驻留机制
1.什么是字符串的驻留机制
字符串驻留:是一种在内存中保存一份相同且不可变字符串的方法。（相同的字符串只保留一份）
不同的值被存放在字符串的驻留池当中,Python的驻留机制对相同的字符串只保留一份拷贝,后续创建相同的字符串时，不会开辟新的空间，而是把字符串的标识地址引用到新的变量元素，保证内存的占用资源
2.驻留适用范围（pycharm软件下直接存在驻留）：
包含字母字符串[a-z]/[A-Z] 的字符串驻留字符串长度为0或1时，默认采用驻留机制
>>> a = '' >>> b = '' >>> a is b True
字符串长度大于1时，且字符串中只包含大小写字母、数字、下划线(_) 时，采用驻留机制
>>> a = "1_2" >>> b = "1_2" >>> a is b True
对于 [-5,256]之间的整数数字，Python默认驻留
a=-5 b=-5 print(a==b) True a1=-6 b1=-6 print(a1==b1) False
字符串 只在编译时进行驻留，而非运行时 。
# 运行时 a = "hello01" b = "hello" print(b + "01" is a) #False # 编译 a = "hello01" b = "hello" +"01" print(a is b) #True
用乘法得到的字符串，如果结果长度 <=20且字符串只包含数字、字母大小写、下划线，支持驻留。长度>20，不支持驻留。保证内存的空间占用不会过大
强制驻留
import sys a='abc%' b='abc%' a=sys.intern(b) print(a is b)字符串的常用操作
a='hello,hello'
print(a.index('lo'))#3
print(a.rindex('lo'))#9
print(a.find('lo'))#3
print(a.rfind('lo'))#9
print(a.find('b'))#-1
a='Gtr,aE86' print(id(a))# 1635893325936 s=a.upper()#转大写 print(s,id(s))#转化后会产生新的id标识 GTR,AE86 1635893337648 s=a.lower()#小写 print(s,id(s))#转化后id标识地址变化 gtr,ae86 1635893328368 print(a.swapcase())#gTRAe86 大小写互相转化 print(a.title())#Gtr,Ae86 首字母大写其余小写 #只要进行大小写转化，标识地址就会发生变化
a='GTR永远的神'
print(a.center(10,'-'))#-GTR永远的神-- 居中对齐,指定宽度10
print(a.center(10))# GTR永远的神 居中对齐，不设定参数默认空格
print(a.ljust(10,'-'))#GTR永远的神--- 左对齐 默认空格
print(a.rjust(10,'-'))#---GTR永远的神 右对齐 默认空格
print(a.zfill(10))#000GTR永远的神 右对齐 0填充
print('-5201314'.zfill(10))#-005201314
print('+5201314'.zfill(10))#+005201314 右对齐，0填充如果遇到+-号默认将+-号置于第一位
a='GTR AE86 Dodge' aa=a.split()#默认分割 默认分割符号为空格 print(aa)#['GTR', 'AE86', 'Dodge'] a1='GTR-AE86-Dodge' print(a1.split())#['GTR-AE86-Dodge'] 没有空格所以不分割 print(a1.split(sep='-'))#['GTR', 'AE86', 'Dodge'] 设置分割符号为- print(a1.split(sep='-',maxsplit=1))#['GTR', 'AE86-Dodge'] 分割一次 print(a1.rsplit())#['GTR-AE86-Dodge'] 与左分割同理，只不过右侧开始分割 print(a1.rsplit(sep='-'))#['GTR', 'AE86', 'Dodge'] 同理 print(a1.rsplit(sep='-',maxsplit=1))#['GTR-AE86', 'Dodge'] 同理 不过从右开始一次
a='GTR,AE86,Dodge'
print(a.isidentifier())#False 变量a1不是合格的标识符
#逗号不属于合法标识符，合法标识符包括数字字母下划线，详细看第二章
a1='GTR'
print(a1.isidentifier())#True
a2='张666'
print(a2.isidentifier())#True
print('isspance:','t'.isspace())#isspance.:True 是否全部回车换行字符制表组成
print('abc:','abc'.isalpha())#abc: True 是否全部字母组成
print('是否10进制数字组成:','A666'.isdecimal())#是否10进制数字组成: False
print('数字符号（包括罗马数字和中文数字符号）：','四'.isnumeric())#数字符号（包括罗马数字和中文数字符号）： True
print('isalnum:','AE86'.isalnum())#isalnum: True 是否全部由数字字母组成
a='my Dodge GTR 1 1'
print(a.replace('1','AE86'))#my Dodge GTR AE86 AE86 进行替换第一个为需要替换，第二个为替换后的词
print(a.replace('1','AE86',1))#my Dodge GTR AE86 1 第三个替换1次
print('-'.join(a))#进行连接 m-y- -D-o-d-g-e- -G-T-R- -1- -1 符号-
print(''.join(a))#my Dodge GTR 1 1 符号空格
#根据ascii表对比
print('apple'>'app')#True
print('apple'>'banana')#False
print(ord('a'),ord('b'))#97 98
#is与==的区别
#is比较的是id是否相等 ==比较value值
a=b='8686'
c='8686'
print(a==b)#True
print(a==c)#True
print(a is b)#True
print(a is c)#True
#因为驻留机制所以同个id和value
s='hello python' #与列表切片同理，起始，结尾，步长 s1=s[:5]#无初始切的位置 s2='!' s3=s[6:]#无最后切的位置 new=s1+s2+s3 print(new)#hello!python print(s[::-1])#nohtyp olleh 负数步长倒着切
#%占位符
name='张三'
age=20
money=17520.42
print('我叫%s，今年%i，存款有%f' % (name,age,money))#我叫张三，今年20，存款有17520.420000
#{}占位符
print('我叫{0}，今年{1}岁'.format(name,age))#我叫张三，今年20岁
#f-string
print(f'我叫{name}，今年{age}岁')#我叫张三，今年20岁
print('%10d' % 99)# 99 10表示宽度
print('%.3f' % 3.149864165161)#3.150 3表示保留多少小数
print('{0:.3}'.format(3.14585151))#3.15 .3表示一共三位
print('{0:.3f}'.format(3.14585151))#3.146 .3 三位小数
print('{0:10.3f}'.format(3.14585151))#宽度为10，一共10位数字 3位小数
#编码 a='我要买GTR' print(a.encode(encoding='GBK'))#GBK编码一个中文2字节 print(a.encode(encoding='UTF-8'))#utf-8编码一个中文2字节 #解码 byte=(a.encode(encoding='GBK')) print(byte.decode(encoding='GBK')) byte=(a.encode(encoding='UTF-8')) print(byte.decode(encoding='UTF-8'))
1、函数的创建和调用
def hanshu(a,b):
c=a+b
return c
2、函数的参数传递
实参-->形参
位置参数；根据对应的实参对形参进行一个萝卜一个坑
def hanshu(a,b):#a,b形参
c=a+b
return c
a=hanshu(10,20)#10,20实参
print((a))
关键字参数：实参根据左侧关键名对应进行形参
def hanshu(a,b):#a,b形参
c=a+b
return c
a=hanshu(b=10,a=20)
print(a)
def fun(arg1,arg2):
print('arg1',arg1)
print('arg2', arg2)
arg1=100
arg2.append(10)
print('arg1', arg1)
print('arg2', arg2)
n1=11
n2=[22,33,44]
print('n1',n1)
print('n2',n2)
fun(n1,n2)#将位置传参，arg1和arg2位形参，n1n2实参，因为是位置传参，实参名参名称可以不一样
print('n1', n1)
print('n2', n2)
#函数调用过程红
#如果不可变对象，函数体的修改不会影响实参 arg1修改为100，不会影响n1
#如果是可变对象，函数体会修改实参的值 aeg修改。append增加10
3、函数的返回值
def fun(num):
odd=[]
even=[]
for i in num:
if i%2:#如果除以2不为0则
odd.append(i)#添加到odd列表
else:
even.append(i)
return odd,even #结束将奇数和偶数的列表返回
#函数调用
lst=[10,29,34,23,44,53,55]
print(fun(lst))#([29, 23, 53, 55], [10, 34, 44])
#1、如果函数没有返回值【函数执行完，不需要给调用处提供数据】return可以不写
def fun1():
print('hello')#hello
#return
fun1()
#2、函数的返回值，如果是一个，直接返回类型
def fun2():
return 'hello'
a=fun2()
print(a)
#3、如果是多个返回值，返回的为元组
def fun3():
return 'hello','world'
print(fun3())
'''函数在定义时，是否需要返回值，视情况而定'''
4、函数的参数定义
def fun(a,b=10):
print(a,b)
#函数调用
fun(100)#100 10 只有一个实参，另一个没有的使用默认参数
fun(20,30)#20 30 有两个实参，直接进行调用
print('hello',end='t')
print('world')
def fun(*weizhi):#函数定义时 可变的位置参数
print(weizhi)
fun(10)#(10,)
fun(10,20)#(10, 20)
fun(10,20,30)#(10, 20, 30)
def fun1(**guanjianzi):#函数定义时 可变的关键字参数
print(guanjianzi)
fun1(a=10)#{'a': 10}
fun1(a=20,b=30,c=40)#{'a': 20, 'b': 30, 'c': 40}
'''
#可变的位置参数只能是一个
def fun2(*weizhi1,weizhi2):
print(weizhi1,weizhi2)
def fun3(*guanjianzi1,guanjianzi2):
print(guanjianzi1,guanjianzi2)
fun2(12,12,23,24)
fun3(a1=11,b1=12,c1=13)
'''
def fun4(*weizhi3,**guanjianzi3):#当同时存在可变的形参，位置参数需要放在关键字参数前面才能运行
pass
def aa(a,b,c):#abc在函数定义处，所以是形参
print('a=',a)
print('b=',b)
print('c=',c)
#调用
aa(10,20,30)#函数调用时的参数传递，称位置实参
lst=[11,22,33]
aa(*lst)#在函数调用时，列表每个元素进行位置实参
print()
aa(a=100,c=300,b=200)#函数调用时传参，关键字实参
dic={'a':111,'b':222,'c':333}#函数调用时，字典每个元素进行关键字实参
aa(**dic)
def aa(a,b,c,d):
print('a=', a)
print('b=', b)
print('c=', c)
print('d=', d)
aa(10,20,30,40)#位置实参
aa(a=10,b=20,c=30,d=40)#关键字实参
aa(11,22,c=33,d=44)#ab位置实参，cd关键字实参
5、变量的作用域
def aa(a,b):
c=a+b#c为局部变量，函数体内定义好的变量，ab为形参，作用范围也是内部，为局部变量
print(c)
aa(10,20)
def aaa():
global age#age本是fun3函数内部定义的局部变量，使用global可以将其变为全局变量
aoe=21
print(aoe)
aaa()
aaa()
print()
6、递归函数
def fac(n):
if n==1:
return 1#如果n=1，输出
else:
return n*fac(n-1)
print(fac(6))
#先进行6阶层 发现不为1，使用else的n*fac（n-1）：相当于n*fac5阶层，一直循环到1结束
#可以理解为fac6=运行fac5*6
#6*（5*（4*（3*（2*（1））））））正向展开 逆向计算
def dinyi(a):
if a==1:
return 1#第一项的时候输出1
elif a==2:
return 1#第二项也输出1
else:
return dinyi(a-1)+dinyi(a-2)#输出（a-1）+（a-2)的和
print(dinyi(6))
for a1 in range(1,7):#遍历1-6
print(dinyi(a1))#进行调用函数计算
