1.字符串相关方法

1.1 计算次数

  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)

1.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() 方法把字符串中的 tab 符号(’\t’)转为空格，tab 符号(’\t’)默认的空格数是 8

字符串.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)

1.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’

1.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***

1.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)

1.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)

2.格式字符串

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

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

2.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.2 format

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

  1. 数据的个数和 {} 的个数保持一致
message = '{}今年{}岁！'.format(name, age)
print(message)
  1. 下标形式的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
  1. 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)

# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
 
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的
  1. f(format)字符串：
    f’{表达式}’
a = 10
b = 20
# 'a=x, b=x'
message = f'a={a+10}, b={b}, c={b}'
print(message) # a=20, b=20, c=20

5)数字格式化

数字

格式

输出

描述

3.1415926

{:.2f}

3.14

保留小数点后两位

3.1415926

{:+.2f}

+3.14

带符号保留小数点后两位

-1

{:+.2f}

-1.00

带符号保留小数点后两位

2.71828

{:.0f}

3

不带小数

5

{:0>2d}

05

数字补零 (填充左边, 宽度为2)

5

{:x<4d}

5xxx

数字补x (填充右边, 宽度为4)

10

{:x<4d}

10xx

数字补x (填充右边, 宽度为4)

1000000

{:,}

1,000,000

以逗号分隔的数字格式

0.25

{:.2%}

25.00%

百分比格式,保留2位小数

1000000000

{:.2e}

1.00e+09

指数记法

13

{:>10d}

13

右对齐 (默认, 宽度为10)

13

{:<10d}

13

左对齐 (宽度为10)

13

{:^10d}

13

中间对齐 (宽度为10)

11

'{:b}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11)

1011 11 13 b 0xb 0XB

进制

^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格

b、d、o、x 分别是二进制、十进制、八进制、十六进制。

此外我们可以使用大括号 {} 来转义大括号，如下实例：

print ("{} 对应的位置是 {{0}}".format("runoob"))  # runoob 对应的位置是 {0}

:.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%

3.函数的作用

飞机移动、发射子弹、敌机自动出现、子弹打中敌机，敌机生命值减少 …
左移1次 右移2次， 左移3次 右移3次

没有函数的问题：

  1. 明明是同样的功能同样的代码需要多少次就要写多少遍 （冗余、重复）
  2. 如果功能发生改变，所有使用过这个功能的位置都需要修改

解决办法：使用函数

def left():
    print('==============左移==============')
    print('看后视镜')
    print('向左打方向盘')
    # print('踩油门')
    print('回正方向盘')


def right():
    print('==============右移==============')
    print('看后视镜')
    print('向右打方向盘')
    # print('踩油门')
    print('回正方向盘')


left()
right()
right()
left()
left()
left()
right()
right()
right()

不使用函数（繁杂）：

print('==============左移==============')
print('看后视镜')
print('向左打方向盘')
print('踩油门')
print('回正方向盘')

print('==============右移==============')
print('看后视镜')
print('向右打方向盘')
print('踩油门')
print('回正方向盘')

print('==============右移==============')
print('看后视镜')
print('向右打方向盘')
print('踩油门')
print('回正方向盘')

print('==============左移==============')
print('看后视镜')
print('向左打方向盘')
print('踩油门')
print('回正方向盘')
print('==============左移==============')
print('看后视镜')
print('向左打方向盘')
print('踩油门')
print('回正方向盘')
print('==============左移==============')
print('看后视镜')
print('向左打方向盘')
print('踩油门')
print('回正方向盘')
print('==============右移==============')
print('看后视镜')
print('向右打方向盘')
print('踩油门')
print('回正方向盘')
print('==============右移==============')
print('看后视镜')
print('向右打方向盘')
print('踩油门')
print('回正方向盘')
#
# print('==============右移==============')
print('看后视镜')
print('向右打方向盘')
print('踩油门')
print('回正方向盘')

4.函数基础

4.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)

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

语法：
def 函数名(形参列表):
函数说明文档
函数体

说明:
def - python定义函数的关键字；固定写法

函数名 - 程序员自己命名：
标识符，不是关键字(要求)；
所有的字母都小写，多个单词之间用下划线隔开；
不能用系统提供的函数名、类名
见名知义（看到函数名大概知道函数的功能是什么）

(): - 固定写法
形参列表 - 格式: 变量名1, 变量名2, 变量名3, … (变量可以是没有定义过的变量)
形参的作用是将函数外面的数据传递到函数里面

函数说明文档 - 和def保持一个缩进的三个双引号引起来的注释 (说明书)
函数体 - 和def保持一个缩进的一条或者多条语句；实现函数功能的一条或者多条语句

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

初学者定义函数的步骤

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

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

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('===============')

4.3 函数的调用（使用机器）

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

说明:
函数名 - 需要调用的函数的名字（函数名必须是已经定义过的函数的函数名）
() - 固定写法

实参列表 - 格式: 数据1, 数据2, 数据3, … (实参的个数和形参的个数保持一致)
作用：用来给形参赋值的。（真正传递到函数中使用的数据）

调用函数会执行函数的函数体，不调用就不会

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

upper_count('hkashAHf8aKsfdP')

func1()

5.函数的参数

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

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

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

单独使用位置参数传参

func1(20, 30, 40)
  1. 关键字参数
    以：形参名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

5.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}')

5.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)