1) count
字符串1.count(字符串2)   -  统计字符串1中字符串2出现的次数
字符串1.count(字符串2, 开始下标=0, 结束下标=字符串1的长度)   -  在字符串1中指定范围内统计字符串2出现的次数
"""
str1 = 'how are you? i am fine, Thank you! And you?'
print(str1.count('you'))     # 3

num = str1.count('you', 0, 11)    # 1
print(num)

2.替换内容

1)replace
字符串1.replace(字符串2, 字符串3)  -  将字符串1中的字符串2全部替换成字符串3
字符串1.replace(字符串2, 字符串3, N)  - 将字符串1中前 N 个字符串2替换成字符串3

str1 = 'how are you? i am fine, Thank you! And you?'
print(str1.replace('you', 'me'))    # how are me? i am fine, Thank me! And me?
print(str1.replace('you', 'me', 1))   # how are me? i am fine, Thank you! And you?

2)expandtabs(抛弃)
字符串.expandtabs()  -  将字符串中的制表符替换成 8 个空格(只针对下标是0的制表符有效，后面是 8 - 3)
字符串.expandtabs(N)  -  将字符串中的制表符替换成 N 个空格 （只针对下标是0的制表符有效，后面是  - 3）

4  -   1      
8  -   5      
9  -   6

str2 = 'Naa\tabc\t123'
new_str2 = str2.expandtabs(2)
print(str2, len(str2))
print(new_str2, len(new_str2))

将制表符替换成8个空格

new_str2 = str2.replace('\t', ' '*8)
print(new_str2)

3.字符串切割

字符串1.split(字符串2)   -  将字符串1按照字符串2为切割点进行切割
字符串1.split(字符串2, N)   -  将字符串1按照字符串2为切割点进行切割,切 N 次
字符串1.rsplit(字符串2, N)  -  将字符串1按照字符串2为切割点进行切割,切 N 次, 从后往前切

str1 = 'how are you? i am fine, Thank you! And you?'
print(str1.split(' '))   # ['how', 'are', 'you?', 'i', 'am', 'fine,', 'Thank', 'you!', 'And', 'you?']
print(str1.split(' ', 2))     # ['how', 'are', 'you? i am fine, Thank you! And you?']
print(str1.rsplit(' ', 2))    # ['how are you? i am fine, Thank you!', 'And', 'you?']


# 'you'  ->  'You'
# 'yOU'  ->  'You'

4.删除字符

字符串1.strip()   -  同时删除字符串最左边和最右边的空白
字符串1.lstrip()  -  删除字符串中最左边的所有空白
字符串1.rstrip()  -  删除字符串中最右边的所有空白

字符串1.strip(字符串2)   -  同时删除字符串最左边和最右边的字符串2
字符串1.lstrip(字符串2)  -  删除字符串中最左边的所有字符串2
字符串1.rstrip(字符串2)  -  删除字符串中最右边的所有字符串2
"""
str3 = '\n\t abc 123\n 你好  \n'
print('============================')
print(str3)
print('============================')
print(str3.lstrip())
print('============================')
print(str3.rstrip())
print('============================')
print(str3.strip())
print('============================')

str4 = '**1**abc123***'
print(str4.strip('*'))    # 1**abc123
print(str4.rstrip('*'))   # **1**abc123
print(str4.lstrip('*'))   # 1**abc123***

5.字符串查找

字符串1.find(字符串2)  -  获取字符串2第一次在字符串1中出现的位置(用正的下标值表示)，如果找不到返回 -1
字符串1.find(字符串2, 开始下标, 结束下标)

str1 = 'how are you? i am fine, Thank you! And you?'
print(str1.find('you'))    # 8

练习1：写代码实现查找字符串str1中所有的 'you’出现的位置

start_index = 0
indexs = []
while True:
    index = str1.find('you', start_index)
    if index == -1:
        break
    start_index = index + 3
    indexs.append(index)
print(indexs)

6.拼接

字符串.join(容器)  -  将容器中元素用指定字符串连接在一起(容器中的元素是字符串)

list1 = ['余婷', '骆昊', '肖世荣']
new_str = ' and '.join(list1)
print(new_str)

new_str2 = '+'.join('abc')
print(new_str2)

练习2：用列表推导式实现将任意容器中的元素用join进行连接

nums = [10, 20, '30', True]
print('+'.join(nums))   # TypeError: sequence item 0: expected str instance, int found

nums = {'name': '余婷', 'age': 18, 'sex': '女'}
new_str3 = ' '.join([str(x) for x in nums.values()])
print(new_str3)

二、格式化字符串

字符串中某一个或者多个部分不确定就可以用格式字符串来实现功能

# name = input('姓名:')
name = '张三'
# age = int(input('年龄:'))
age = 18
# message = 'XXX今年XX岁！'
message = name+'今年'+str(age)+'岁！'
print(message)

1.格式占位符

语法：
包含格式占位符的字符串 % (数据1, 数据2, 数据3, ...)     

说明：
a. 数据个数和前面占位符的个数保持一致
b. 格式占位符： 
    %d  -  整数
    %Nd/%-Nd  - 整数填充字符串的时候宽度是N,不够的用空格在前面/后面占位
    
    %f  -  小数
    %.Nf - .N表示保留N位小数
    
    %s  -  字符串
    
注意：一般情况下占位符和数据的类型需要保持一致，只有 %s 可以用任何类型的数据填充
"""
message = '%s今年%-5d岁,年薪：%.2f' % (name, age, 20000)
print(message)

2.format

在字符串中通过 {} 来占位表示字符串中变化的部分

1) 数据的个数和 {} 的个数保持一致

message = '{}今年{}岁！'.format(name, age)
print(message)

2) 下标形式的format: {下标}

# '你好我是XXX。 XXX你好！'
message = '你好我是{0}。{0}你好！'.format(name)
print(message)

str1 = '{1}={0}={1}'.format(10, 20)
print(str1)   # 20=10=20

str2 = '{1}={2}={0}={1}'.format(1, 2, 3, 4)
print(str2)   # 2=3=1=2

3) key形式的format: {key}

str3 = '{0}今年{1}岁，{0}的得分是:{2}'.format('张三', 18, 78)
print(str3)
str3 = '{name}今年{age}岁，{name}的得分是:{score}'.format(name='张三', age=18, score=78, height=180)
print(str3)

4) f(format)字符串：

f'{表达式}'
"""
a = 10
b = 20
# 'a=x, b=x'
message = f'a={a+10}, b={b}, c={b}'
print(message)

5)数字格式化

:.Nf - 限制小数的小数点位数(N位)
:x>Nd - 数字占N位，不够用x填充(填在左边)
:x<Nd - 数字占N位，不够用x填充(填在右边)
:, - 用逗号将数据进行分隔（通用于银行数据显示）
:.N% - 以百分比的形式显示数据，数据保留 N 位小数

print('数字:{:.2f}'.format(3.1415926))    # 数字:3.14
print('数字:{1:.2f}'.format(3.1415926, 1.68926))     # 数字:1.69
print('数字:{n2:.2f}'.format(n1=3.1415926, n2=2.34233))    # 数字:2.34
pi = 3.1415926
print(f'数字:{pi:.2f}')    # 数字:3.14

print('{:0>5d}'.format(34))      # 00034
print(f'{34:a>5d}')      # aaa34
print(f'{34: >5d}')      #    34

print(f'{34:a<5d}')      # 34aaa

num = 19029300000
print(f'{num:,}')      # 19,029,300,000

num = 0.45
print(f'{num:.2%}')     # 45.00%

三、函数基础

1.什么是函数

1)概念(最重要！)

函数就是对实现某一特定功能的代码段的封装 (机器)

2)分类(谁定义的)

系统函数 - 系统已经定义了，程序可以直接使用的函数；比如：print、input、type、ord、chr、bin、len、id等等。（别人造好的机器）
自定义函数 - 程序员自己定义使用的函数。（自己造的机器）

# n = 10
# sum1 = 1
# for x in range(1, n+1):
#     sum1 *= x
# print(sum1)
#
# n = 20
# sum1 = 1
# for x in range(1, n+1):
#     sum1 *= x
# print(sum1)


def jiecheng(n):
    sum1 = 1
    for x in range(1, n+1):
        sum1 *= x
    print(sum1)


# jiecheng(10)
# jiecheng(20)
# jiecheng(5)

2.函数的定义(自己造机器)

语法：
def 函数名(形参列表):
    函数说明文档
    函数体
    
说明:
def  -  python定义函数的关键字；固定写法
函数名 - 程序员自己命名：
        标识符，不是关键字(要求)；
        所有的字母都小写，多个单词之间用下划线隔开；
        不能用系统提供的函数名、类名
        见名知义（看到函数名大概知道函数的功能是什么）
():  -  固定写法
形参列表   -  格式: 变量名1, 变量名2, 变量名3, ...  (变量可以是没有定义过的变量)
             形参的作用是将函数外面的数据传递到函数里面
函数说明文档  -  和def保持一个缩进的三个双引号引起来的注释 (说明书)
函数体  -  和def保持一个缩进的一条或者多条语句；实现函数功能的一条或者多条语句


(重要！)注意: 函数在定义的时候不会执行函数体

初学者定义函数的步骤

第一步：确定函数的功能
第二步：根据函数的功能确定函数名
第三步：确定函数的参数(看实现函数的功能需不需要额外的数据，需要几个)
第四步：实现函数功能
（第五步: 确定函数返回值）
第六步：写函数说明文档

需求：定义一个函数实现求任意两个数的和的功能

扫描二维码关注公众号，回复： 11354327 查看本文章

def yt_sum(num1, num2):
    """
    求两个数的和(功能说明部分)
    :param num1: 第一个数
    :param num2: 第二个数
    :return: None(返回值说明)
    """
    print(num1 + num2)

练习1：定义一个函数，打印指定字符串中大写字母的个数

def upper_count(string):
    """
    统计指定字符串中大写字母的个数
    :param string: 被统计的字符串
    :return: None
    """
    count = 0
    for x in string:
        if 'A' <= x <= 'Z':
            count += 1
    print(f'{string} 中大写字母的个数：{count}')


def func1():
    list1 = [1, 2, 3]
    print(list1[100])
    print('===============')

3. 函数的调用（使用机器）

语法：
函数名(实参列表)

说明:
函数名  -  需要调用的函数的名字（函数名必须是已经定义过的函数的函数名）
()     -  固定写法
实参列表  -  格式: 数据1, 数据2, 数据3, ...   (实参的个数和形参的个数保持一致)
            作用：用来给形参赋值的。（真正传递到函数中使用的数据）
            
调用函数会执行函数的函数体

yt_sum(20, 30)
yt_sum(7, 68)

upper_count('hkashAHf8aKsfdP')

func1()

四、函数的参数

1. 位置参数和关键字参数(实参分类)

1)位置参数

实参直接写(直接将多个数据用逗号隔开)，让实参和形参从位置上一一对应

def func1(a, b, c):
    print(f'a:{a}, b:{b}, c:{c}')

单独使用位置参数传参

func1(20, 30, 40)

2) 关键字参数

以：形参名1=值1,形参名2=值2,… 的形式传参

注意: 要保证每个参数都有值

单独使用关键字参数传参

func1(a=20, b=30, c=40)
func1(b=30, c=40, a=20)

3)位置参数和关键字参数混合

要求: 位置参数必须在关键字参数的前面

func1(10, c=30, b=20)    # a:10, b:20, c:30
func1(10, 20, c=30)    # a:10, b:20, c:30
# func1(a=10, 20, 30)  # SyntaxError: positional argument follows keyword argument

2.参数默认值(形参)

定义函数的时候可以以：形参名=值的形式给参数赋默认值, 调用函数的时候有默认值的参数可以不用传参

注意: 没有默认值的参数必须放在有默认值参数的前面

所有的参数都有默认值

def func2(x=10, y=20, z=30):
    print(f'x:{x}, y:{y}, z:{z}')


func2()     # x:10, y:20, z:30
func2(100)   # x:100, y:20, z:30
func2(y=200)  # x:10, y:200, z:30


def func3(y, x=10, z=30):
    print(f'x:{x}, y:{y}, z:{z}')

3. 不定长参数(定义)

定义参数的时候参数个数不确定就可以使用不定长参数

1) 在形参前加 *

带一个*的形参，本质就是一个元组，对应的实参会作为这个元组的元素。
这种不定长参数的函数只能用位置参数传参

2) 在形参前加 **

带两个*的形参，本质就是一个字典，对应的实参会作为这个字典的值。
这种不定长参数的函数只能用关键字参数传参

例子：定义一个函数可以求多个数的和

def yt_sum(*num):
    sum1 = 0
    for x in num:
        sum1 += x
    print(sum1)


yt_sum(1)
yt_sum(10, 20)
yt_sum(1, 2, 3, 4, 5)


def yt_sum2(**num):
    print(num)


yt_sum2(a=10, b=20)

day10-python字符串和函数

文章目录

day10-字符串和函数

一、字符串相关方法

1.计算次数