【史上最细Python教程】第三篇：字符串与函数，越学越上头的python，你确定不来看看？

💖少年的书桌上，没有虚度的光阴！💖

系列文章目录🍁

第一篇：基础语法与结构
第二篇：Python四大内置数据结构

---

文章目录

• 系列文章目录🍁
• 🌴前言
• 🌿
  

  一、字符串

• • 1.字符串的驻留机制
  • 2.字符串的常用 *** 作
  • • 查询 *** 作
    • 大小写转换 *** 作
    • 字符串内容对齐 *** 作
    • 字符串的分割
    • 判断字符串中内容
    • 字符串替换
    • 字符串合并
  • 3.字符串的比较
  • 4.字符串的切片 *** 作
  • 5.格式化字符串
  • • 为什么需要格式化字符串？
    • 格式化字符串的三种方式
  • 6.字符串的编码转换
• 🌿
  

  二、函数

• • 1.函数的创建与使用
  • 2.函数的参数传递
  • 3.函数的返回值
  • 4.函数的参数定义
  • • 函数参数定义默认值
    • 个数可变的位置参数
    • 个数可变的关键字形参
  • 5.变量的作用域
  • 6.递归函数
  • • 递归函数的组成部分
    • 递归的调用过程
• 🌴总结

---

🌴前言

大家好，我是小沐！😃编程路上一个人可能走的更快，但一群人才能走得更远，关注小沐一起学习不迷路！今天分享的是 python中字符串与函数的知识，话不多说，秃头走起——>冲冲冲👊👊👊！！！

---

🌿

一、字符串 1.字符串的驻留机制

字符串：在Python中字符串是一种基本数据类型，是不可变序列。

字符串的驻留机制：对于相同的字符串只保留一份拷贝，后序创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量。

字符串可用单、双、三引号进行定义。

a='Python'
b="Python"
c='''Python'''
print(a,id(a)) # Python 2147104589936
print(b,id(a)) # Python 2147104589936
print(c,id(c)) # Python 2147104589936

驻留机制的几种情况（交互模式）：
字符串的长度为0或1时；
符合标识符的字符串（由字母数字下划线组成，但这里数字可以开头）；
字符串只在编译时进行驻留，而非运行时；
[-5,256]之间的整数数字。

import sys
sys中的intern方法强制两个字符串指向同一个对象，即同一块地址。

import sys
a=sys.intern(b)
PyCharm和一些编译器对字符串进行了优化处理，具有驻留机制

在进行字符串拼接时，我们要尽量使用str类型的join方法，而非+
因为join()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率比+高

2.字符串的常用 *** 作 查询 *** 作

# 四种方法 index() rindex() find() rfind()
s='hello,worldlo'
#第一种 index() 查找子串第一次出现的位置，如果查找的子串不存在时，则抛出ValueError
print(s.index('lo')) #3
#第二种 rindex() 查找子串最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError
print(s.rindex('lo')) #11print(s.rindex('ss'))
#第三种 find() 查找子串第一次出现的位置，如果查找的子串不存在时，则返回-1
print(s.find('lo'))
print(s.find('ss')) #-1
#第四种 rfind() 查找子串最后一次出现的位置，如果查找的子串不存在时，则返回-1
print(s.rfind('lo'))
print(s.rfind('ss')) #-1

大小写转换 *** 作

# 五种方法 upper() lower() swapcase() capitalize() title()
s='hello,PyThon'
# 第一种 upper() 把字符串中所有字符都转成大写字母
print(s.upper())
# 第二种 lower() 把字符串中所有字符都转成小写字母
print(s.lower())
# 第三种 swapcase() 把字符串中所有大写字母转成小写字母，所有小写字母转成大写字母
print(s.swapcase())
# 第四种 capitalize() 把第一个字符转换成大写，其余字符转换成小写
print(s.capitalize())
# 第五种 title() 把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换成小写
print(s.title())

注意：字符串是不可变序列，所以在进行上述方法时，都创建了新的对象，即前后两个变量id不一致。

字符串内容对齐 *** 作

# 四种方法 center() ljust() rjust() zfill()
s='hello,python'
# 第一种 center() 居中对齐 第一个参数指定宽度，第二个参数指定填充符，第二个参数可选，默认为空格，如果设置宽度小于实际宽度则返回原字符串
print(s.center(20,'*'))
# 第二种 ljust() 左对齐 第一个参数指定宽度，第二个参数指定填充符，第二个参数可选，默认为空格，如果设置宽度小于实际宽度则返回原字符串
print(s.ljust(20,'*'))
# 第三种 rjust() 右对齐 第一个参数指定宽度，第二个参数指定填充符，第二个参数可选，默认为空格，如果设置宽度小于实际宽度则返回原字符串
print(s.rjust(20,'*'))
# 第四种 zfill() 右对齐 左边用0填充，该方法只接受一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，则返回字符串本身
print(s.zfill(20))
print('-12345'.zfill(20))  # - + 号等会置于第一位

字符串的分割

#两种方法 split()  rsplit()
s='h|ello wor|ld pyt|hon'
# 第一种 split() 从字符串的左边开始分割，默认的分割字符是空格字符串，返回的值都为一个列表
lst1=s.split()
print(lst1)
#以通过参数sep指定分割字符串的是分隔符
lst1=s.split(sep='|')
print(lst1)
#通过参数maxsplit指定分割字符串时的最大分割次数，在经过最大分割次数后，剩余的子串会单独作为一部分
lst1=s.split(sep='|',maxsplit=1)
print(lst1)

#第二种 rsplit() 从字符串的右边开始分割，默认的分割字符是空格字符串，返回的值都为一个列表
lst2=s.rsplit(sep='|',maxsplit=1)
print(lst2) 

只有当指定最大 *** 作次数时两种方法才有所差别。

判断字符串中内容

#五种方法  isidentifier() isspace() isalpha() isdecimal() isnumeric() isalnum()
s='hello,python'
#第一种 isidentifier() 判断指定的字符串是不是合法的标识符
print('1',s.isidentifier())
print('2','hello'.isidentifier())
print('3','苏沐_'.isidentifier())   #注意python可以用汉字作变量，标识符规则和C有所不同
#第二种 isspace() 判断指定的字符串是否全部由空白字符组成（回车，换行，水平制表等）
print('4','\t'.isspace())
#第三种 isalpha()判断指定的字符串是否全部由字母组成
print('5','python'.isalpha())
print('6','苏沐'.isalpha())
print('7','苏沐666'.isalpha())
#第四种 isdecimal()判断指定字符串是否全部由十进制的数字组成
print('8','666'.isdecimal())
print('9','ⅡⅡⅡ'.isdecimal())
#第五种 innumeric() 判断指定的字符串是否全部由数字组成
print('10','123一二三ⅡⅢ'.isnumeric())   #十进制、汉字、罗马数字都是数字
#第六种 isalnum()判断指定字符串是否全部由数字和字母组成
print('11','aA苏沐六lⅥ6'.isalnum())

字符串替换

s='hello,python,python,python'
# replace() 第一个参数指定被替换的子串，第二个参数指定替换字串的字符串，该方法返替换后得到的字符串，替换前的字符串不发生变化，可以添加第三个参数指定最大替换次数
print(s.replace('python','world'))   #hello,world,world,world
print(s.replace('python','worls',2)) #hello,worls,worls,python

字符串合并

lst=['hello','world','python']
t=('hello','world','python')
# join() 将列表或元组中的字符串合并成一个字符串
print('|'.join(lst))  #hello|world|python
print(''.join(lst))  #helloworldpython
print(''.join(t))   #helloworldpython
print('*'.join('python')) #p*y*t*h*o*n

3.字符串的比较

运算符：
> >= < <= == !=

比较原理：
** 两字符比较时，比较的是其ordinal value（原始值），调用内置函数ord可以得到指定字符的ordinal value;**
与ord对应的是内置函数chr,调用内置函数chr时指定ordinal valye可以得到其对应的字符。

print('apple'>'app') #True
print(ord('a'),ord('c')) #97 99
print(chr(99),chr(100))  #c d

==与is的区别：
==比较两个变量的值
is比较两个变量的地址

4.字符串的切片 *** 作

字符串为不可变序列，不具备增删改 *** 作，切片将产生新的对象。

*** 作同列表的切片。

# s[start:end:step]  步长为负从end开始
s='hello,world'
s1=s[:5]
s2=s[6:]
s3='!'
print(s1,s2,s3) #hello world !
newstr=s1+s3+s2 #hello!world
print(newstr)

5.格式化字符串 为什么需要格式化字符串？

在填写请假条等的时候，有些内容是打印出来的纸上本来就有的，而空着的是需要我们去填写的？可以看作是格式化了的。

格式化字符串的三种方式

# 第一种 %作占位符
name='苏沐'
age=20
print('我叫%s,今年%d岁了 ' % (name,age))
# 第二种 {}作占位符
print('我是{0},今年{1}岁了'.format(name,age)) #0，1为下标，需要用到format方法
# 第三种 f-string
print(f'我叫{name},今年{age}岁了') #我叫苏沐,今年20岁了

还可以调整宽度和精度

print('%10d' % 99)  #10表示宽度
print('%.3f' % 3.1415926535) # .3表示小数点后三位
print('%10.3f' % 3.1415926535)

print('{0:.3}'.format(3.1415926535)) #.3表示三位数
print('{0:.3f}'.format(3.1415926535)) #.3f表示三位小数
#0表示占位符的顺序，只有一个时，可写可不写
print('{0:10.3f}'.format(3.1415926535)) #同时设置宽度，精度

上述内容学过C的铁子们应该很好理解！

6.字符串的编码转换

要把A计算机中的字符串在B计算机上显示出来的话，由于字符串在A中是以unicode表示的，，所以需要编码，再通过字节传输，然后B计算机解码显示。

编码：将字符串转换为二进制数据
解码：将二进制数据转换成字符串类型

#编码
s='永远的神'
print(s.encode(encoding='GBK')) #在GBK这种编码格式中，一个中文占两个字节
print(s.encode(encoding='utf-8')) #在UTF-8这种编码格式中，一个中文占三个字节
#解码
#byte代表一个二进制数据（字节类型的数据）
byte=s.encode(encoding='GBK')
print(byte.decode(encoding='GBK')) #解码

编码和解码的格式一定要相同

🌿

二、函数

在学习各种语言的过程中大家一起都在使用函数，这里不再赘述，简单来说，函数就是执行特定任务和完成特定功能的一段代码,我们常用的print()、input()、id()等等都是函数；
有小伙伴会说，不用行不行啊？
啊行行行，当然可以。

但是这样代码太过于繁琐，使用函数可以封装代码使代码实现复用，隐藏实现的细节，提高代码维护性，提高可读性便于调试。

说了这么多废话，直接上手吧兄弟们——>

1.函数的创建与使用

创建语法：
def 函数名（ 输入参数）:
函数体
return xxx（可省略不写）

#函数的定义
def 苏沐(a,b):
    c=a+b
    return c
#函数的调用
num=苏沐(10,20)
print(num)

这里python中的标识符可以为汉字

2.函数的参数传递

在上例中，a,b出现在函数定义处，称为形参；
10，20出现在函数调用出，称为实参。

有这么两种参数传递方式：
位置传参：
将（10，20）对应于（a,b）的位置进行计算，上例就是这么完成的嘞！
关键字传参：
实参赋给名称相同的形参！当参数名称不同时，按位置传参。

#函数的创建
def 苏沐(a,b):
    return a
#函数的调用
num=苏沐(b=22,a=15)
print(num) #15

在函数调用过程中：

如果是不可变对象，在函数体内的修改不会影响实参的值
可变对象：列表list、 字典dict 、集合
不可变对象： 整型int、 浮点型float 、字符串型string 、元组tuple
如果是可变对象，在函数体内的修改会影响到实参的值

def fun(num1,num2):
    print('num1:',num1)
    print('num2:',num2)
    num1=99
    num2.append(10)
    print('num1:',num1)
    print('num2:',num2)

a=11
b=[10,20,30]
print('a:',a)
print('b:',b)
fun(a,b)
print('a:',a)
print('b:',b)

3.函数的返回值

函数返回多个值使，结果为元组。

def fun(num):
    odd=[] #存奇数
    even=[] #存偶数
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even
lst=[11,22,33,44]
print(fun(lst)) #([11, 33], [22, 44])

函数返回值：
如果函数没有返回值，return可以省略不写；
返回值如果是一个，直接返回类型；
返回值如果是多个，返回的结果为元组。

4.函数的参数定义 函数参数定义默认值

函数定义时，可以给形参设置默认值，只有当与默认值不符的时候才需要传递实参。

def fun(a,b=10):  #b为默认值参数
    print(a,b)
fun(100) #100 10
print(20,30) # 20 30

print('hello',end='\t')  #print函数默认值为换行\n，改为\t则两行输出在同一行
print('world')

个数可变的位置参数

定义函数时，当无法事先确定传递的位置参数的个数时，使用可变的位置参数。

使用*定义个数可变的位置形参，结果为一个元组

def fun(*args):
    print(args)
    print(args[0])
fun(10,)
fun(10,20)
fun(10,20,30)
'''
输出如下：
(10,)
10
(10, 20)
10
(10, 20, 30)
10
'''

个数可变的关键字形参

定义函数时，无法实现确定传递的关键字实参的个数时，使用可变的关键字形参；使用**定义可变的关键字形参，结果为一个字典

def fun(**args):
    print(args)
fun(a=10)
fun(a=10,b=20,c=30)
'''
输出如下：
{'a': 10}
{'a': 10, 'b': 20, 'c': 30}
'''

注意：
可变的位置参数和关键字参数都只能有一个，两者都存在的时候，个数可变的位置形参要放在个数可变的关键字形参的前面，下述函数123会报错，4不报错。

def fun1(*args1,*args2):
    pass
def fun2(**args1,**args2):
    pass
def fun3(**args1,*args2):
    pass
def fun4(*args1,**args2):
    pass

下面是一些值得注意的点：

def fun(a,b,c):
    pass
lst=[10,20,30]
fun(lst) #报错
fun(*lst) #将序列中的每个元素都转换为位置参数传入，使用*
dic={'a':100,'b':200,'c':300}
fun(dic) #报错
fun(**dic) #将字典中的键值对都转换为关键字实参传入，使用**

#如果要使c,d参数只能用关键字参数传递，如何做？
def fun(a,b,*,c,d):
    pass
fun(10,20,c=30,d=40)

#函数定义时的形参的顺序问题
#以下定义都是正确的
def fun1(a,b,*,c,d,**args):
    pass
def fun2(*args1,**args2):
    pass
def fun3(a,b=10,*args1,**args2):
    pass

5.变量的作用域

作用域即程序代码能访问该变量的区域
根据变量的有效范围分为局部变量和全局变量。

局部变量：
在函数体内定义并使用的变量，只在函数体内有效，局部变量使用global声明，这个变量就会称为全局变量。

(值得一提的是，要先调用一次函数）

def fun():
    global a 
    a=20
fun()
print(a)

全局变量：
函数体外定义的变量，可作用于函数体内外。

6.递归函数

递归？啥是递归？
如果我们在一个函数内调用了该函数本身，这个函数就称为递归函数

递归函数的组成部分

递归调用条件与递归终止条件

#求阶乘
def fac(num):
    if num==1:
        return 1
    else:
        return num*fac(num-1)

print(fac(7)) #5040

#斐波那契数列
def fib(n):
    if n==1 or n==2:
        return 1
    else:
        return fib(n-1)+fib(n-2)
print(fib(8))

递归的调用过程

每调用一次函数，都会在栈内分配一个栈帧；
每执行玩一次函数，都会释放相应的空间。

递归函数的思路和代码都比较简单，很容易就能够写出来，但是占用的内存较多，效率比较低。

---

🌴总结

今日分享到此结束👊👊👊，由于笔者还在求学跨考之路上辗转徘徊🏃，水平有限，文章中可能有不对之处，还请各位大佬指正🙏，祝愿每一个热爱编程的人都能实现追求，考研上岸进大厂，熬夜秃头卷中王。

最后欢迎关注小沐，学习路上不迷路！😜