python第2课：函数、字符串

本节课内容

• 函数+参数
• 字符串str + 字符串内置函数

- 函数+参数

# 函数定义
def func():
    print("hehehe")
    print("hahaha")

func()

hehehe
hahaha

函数的参数和返回值

• 参数：负责给函数传递一些必要的数据或者信息
  • 形参（形式参数）：在函数定义时使用的参数，没有具体值，只是个占位符
  • 实参（实际参数）：再调用函数时输入值
• 返回值：调用函数时的一个执行结果
  • 使用return返回结果
  • 如果没有值需要返回，推荐用return None表示函数结束
  • 函数一旦执行return，则函数立即停止
  • 如果函数没有return关键字，则函数默认返回None

# 形参和实参的案例
# 参数person只是一个符号
# 调用的时候用另一个
def hello(person):
    print("{},你好吗？".format(person))
    print(f"{person},我好！")

p = "小明"
# 调用函数
hello(p)

小明,你好吗？
小明,我好！

p = "小花"
hello(p)

小花,你好吗？
小花,我好！

pp = hello("婷婷")
print(pp)

婷婷,你好吗？
婷婷,我好！
None

如果需要帮助，可以使用help调出官方文档

# help为你提供帮助
help(print)

Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

# 九九乘法表
# range为左闭右开区间
# version 1.0
for i in range(1,10):
    for j in range(1,i+1):
        print("{}*{}={:2}".format(j,i,i*j),end=", ") # 以逗号和一个空格结尾，print（）默认换行输出，可见官方文档end="\n"为换行
    print("")
# 占位符：输出时不够两位则会在前面加空格实现两位占位“:2”中2为格式占位符，表示占两格

1*1= 1, 
1*2= 2, 2*2= 4, 
1*3= 3, 2*3= 6, 3*3= 9, 
1*4= 4, 2*4= 8, 3*4=12, 4*4=16, 
1*5= 5, 2*5=10, 3*5=15, 4*5=20, 5*5=25, 
1*6= 6, 2*6=12, 3*6=18, 4*6=24, 5*6=30, 6*6=36, 
1*7= 7, 2*7=14, 3*7=21, 4*7=28, 5*7=35, 6*7=42, 7*7=49, 
1*8= 8, 2*8=16, 3*8=24, 4*8=32, 5*8=40, 6*8=48, 7*8=56, 8*8=64, 
1*9= 9, 2*9=18, 3*9=27, 4*9=36, 5*9=45, 6*9=54, 7*9=63, 8*9=72, 9*9=81, 

def jiujiu():
    for i in range(1,10):
        for j in range(1,i+1):
            print("{}*{}={:2}".format(j,i,i*j),end=", ") 
        print("")

jiujiu()
jiujiu()

1*1= 1, 
1*2= 2, 2*2= 4, 
1*3= 3, 2*3= 6, 3*3= 9, 
1*4= 4, 2*4= 8, 3*4=12, 4*4=16, 
1*5= 5, 2*5=10, 3*5=15, 4*5=20, 5*5=25, 
1*6= 6, 2*6=12, 3*6=18, 4*6=24, 5*6=30, 6*6=36, 
1*7= 7, 2*7=14, 3*7=21, 4*7=28, 5*7=35, 6*7=42, 7*7=49, 
1*8= 8, 2*8=16, 3*8=24, 4*8=32, 5*8=40, 6*8=48, 7*8=56, 8*8=64, 
1*9= 9, 2*9=18, 3*9=27, 4*9=36, 5*9=45, 6*9=54, 7*9=63, 8*9=72, 9*9=81, 
1*1= 1, 
1*2= 2, 2*2= 4, 
1*3= 3, 2*3= 6, 3*3= 9, 
1*4= 4, 2*4= 8, 3*4=12, 4*4=16, 
1*5= 5, 2*5=10, 3*5=15, 4*5=20, 5*5=25, 
1*6= 6, 2*6=12, 3*6=18, 4*6=24, 5*6=30, 6*6=36, 
1*7= 7, 2*7=14, 3*7=21, 4*7=28, 5*7=35, 6*7=42, 7*7=49, 
1*8= 8, 2*8=16, 3*8=24, 4*8=32, 5*8=40, 6*8=48, 7*8=56, 8*8=64, 
1*9= 9, 2*9=18, 3*9=27, 4*9=36, 5*9=45, 6*9=54, 7*9=63, 8*9=72, 9*9=81, 

# 改造上面函数
def printLine(line_num):
    for i in range(1,line_num+1):
        print("{}*{}={:2}".format(i,line_num,line_num*i),end=", ")
    print("")
def jiujiu():
    for i in range(1,10):
        printLine(i)
jiujiu()

1*1= 1, 
1*2= 2, 2*2= 4, 
1*3= 3, 2*3= 6, 3*3= 9, 
1*4= 4, 2*4= 8, 3*4=12, 4*4=16, 
1*5= 5, 2*5=10, 3*5=15, 4*5=20, 5*5=25, 
1*6= 6, 2*6=12, 3*6=18, 4*6=24, 5*6=30, 6*6=36, 
1*7= 7, 2*7=14, 3*7=21, 4*7=28, 5*7=35, 6*7=42, 7*7=49, 
1*8= 8, 2*8=16, 3*8=24, 4*8=32, 5*8=40, 6*8=48, 7*8=56, 8*8=64, 
1*9= 9, 2*9=18, 3*9=27, 4*9=36, 5*9=45, 6*9=54, 7*9=63, 8*9=72, 9*9=81, 

参数详解

• 参数分类
  • 普通参数/位置参数
  • 默认参数
  • 关键字参数
  • 收集参数

# 普通参数案例
def normal_para(one, two, three):
    print(one + two)
normal_para(1,2,3)
# 形参有多少调用时的实参就要有多少，不管传参后有没有用到

3

# 默认参数
# 第三个参数如果没有实参传入则默认为3，有传入则使用传入的实参
def default_para(one, two, three=3):
    print(one + two + three)
default_para(1,2,10)

13

# 关键字参数
# 让函数调用时不依赖参数的位置顺序传参
def keys_para(one, two, three):
    print(one + two + three)

keys_para(one=1, two=2, three=3)

keys_para(two=2, three=3, one=1)

6
6

- 字符串str

• str
• 转义字符
• 格式化
• 内建函数

字符串

• 表示文字信息
• 用单引号，双引号，三引号括起来

a = "阿巴八阿巴"
b = 'hehehe'
print(a)
print(b)

阿巴八阿巴
hehehe

c = '''
I
Love
You
'''
print(c)
# 三引号保留字符串格式

I
Love
You

转义字符

• 用一个特殊的方法表示出一系列不方便写出来的内容，比如回车键，换行键，退格键等
• 借助反斜杠字符，一旦字符串出现反斜杠，则反斜杠后面一个或几个字符表示的已经不是原来的意思了，进行了转义
• 在字符串中，一旦出现反斜杠就要倍加小心，可能有转义字符出现
• 再不同系统下换行操作有不同的表示：
  • windows：\n
  • Linux：\r\n

s = "Let's Go"   # 这里是因为外面使用双引号括起来的所以默认一个单引号就是一个单引号 
print(s)

Let's Go

# 转义字符案例
s = 'Let\'s Go'
print(s)

Let's Go

# 两个反斜杠表示一个斜杠
s = "C:\\\\路径\\user"
print(s)

C:\\路径\user

# 回车换行
# win系统下\r\n也表示换行
s = "回车\n换行"
s1 = "回车\r\n换行"
print(s)
print("")# 输出空行
print(s1)

回车
换行

回车
换行

常用转义字符

\   在行尾时是     续行符
\\   反斜杠符号
\' 单引号
\"  双引号
\a  响铃
\b  退格
\e  转义
\000 　空　
\n     换行
\v　　纵向制表符
\t      横向制表符
\r    回车
\f     换页
\oyy   八进制数，yy代表字符，如 \o12 代表换行
\xyy  十六进制数  yy代表字符，如\x0a代表换行
\other 其他字符一普通格式输出

单个反斜杠表示这一行内容没结束，下一行继续执行

字符串格式化

• 传统格式化
• format

传统格式化方法

• 使用%号进行格式化
• %也叫占位符
  %d 整数
  %f 浮点数
  %s 字符串
  %x 十六进制整数

# %s 表示简单字符串
s = "I Love %s"
print(s%"hehe")
print(s)

I Love hehe
I Love %s

print("I Love %s"%"hehe")
# 占位符一般只能被同类型替换，或者替换类型能被转换成占位符的类型
s_list = [1,2,3] # 这里的列表类型可以转换成字符串类型
print("I Love %s"%s_list)

I Love hehe
I Love [1, 2, 3]

s = "hehe 今年 %d 岁了"
print(s%18)
# print(s%"18")    这样写就不行“18”为字符串

hehe 今年 18 岁了

s = "hehe 今年重 %f千克 ,%f米高"
s_1 = "hehe 今年重 %.2f千克 ,%.3f米高"
print(s%(60.5,2))
print(s_1%(60.5,2))

hehe 今年重 60.500000千克 ,2.000000米高
hehe 今年重 60.50千克 ,2.000米高

format格式化

• 使用函数形式进行格式化，代替以前的百分号

# 不用指定位置，按顺序读取
# 方式一
s = "{} {}!"
print(s.format("Hello","World"))
print()

# 方式二
s = "{} {}!".format("Hello","World")
print(s)
print()

# 设置指定位置
s = "{0} {1}!".format("Hello","World")
print(s)
print()

# 设置指定位置
s = "{1} {0}!".format("Hello","World")
print(s)
print()

# 设置指定位置
s = "{0} {0}!".format("Hello")
print(s)
print()

# 使用命名参数
s = "我们是{team_name}团队,我们的网址是{url},{name}最帅"
s = s.format(team_name="奥里给",url="www.abc.com",name="李明特")
print(s)

Hello World!

Hello World!

Hello World!

World Hello!

Hello Hello!

我们是奥里给团队,我们的网址是www.abc.com,李明特最帅

# 通过字典设置参数，需要解包
s = "我们是{team_name}团队，我们的网址是{url}，{name}最帅"
s_dict = {"team_name":"奥里给","url":"www.abc.com","name":"李明特"}
s = s.format(**s_dict)  # **为解包操作
print(s)

我们是奥里给团队，我们的网址是www.abc.com，李明特最帅

对数字的格式化

• “：”，后面带填充的字符，只能是一个字符，不指定则默认是用空格填充
• “+” ，表示在正数前显示+，负数前显示-
• b,d,o,x 分别是二进制，十进制，八进制，十六进制
• 此外我们还可以使用大括号{}来转义大括号

s = "li is {:.2f}m heigh,{:.2f}kg weight"
print(s.format(1.84453,76.45232))

li is 1.84m heigh,76.45kg weight

str内置函数

• 字符串查找类：find，index
  • find：查找字符串中是否包含一个子串
  • index：和上面的find一样，只是找不到的话会报错
• 字符串判断类（一般都用is开头）：islower,isalpha
  • islower:判断字符串是否是小写
    • 字符串中有空格自动忽略
    • 汉字无大小写概念，返回False
  • issupper:判断字符串是否大写
    • 字符串中有空格自动忽略
    • 汉字无大小写概念，返回False
  • isalpha:判断是否是字母
    • 此函数默认字符串非空，否则返回False
    • 字符串中有空格也会返回False
    • 汉字被认为是alpha，所以此函数不能作为区分英语字母韩式汉字的标识，区分中英文请使用Unicode码
• 字符串内容判断类：startswith/endswith
• 想要判断的话推荐使用正则表达式

# find
s = "123456789123456789"
s_1 = "345"
s_2 = "abc"
# 返回第一次发现这个字符串的位置,从0开始
print(s.find(s_1))   # 找到则返回位置
print(s.find(s_2))  # 找不到则返回-1

2
-1

# find加区间，具体可help查看官方文档,有一个start和end参数
s = "123456789123456789"
s_1 = "345"
s.find(s_1,10)
# 这返回的是从第10位后面开始找的字符串位置

11

# startswith/endswith示例
help(str.startswith)
print("")


# prefix为被检查的字符串
# start检查开始位置
# end检查停止位置
a = "123456789123456789"
b = "789"
c = "123"
print("a是否以b为结尾：{}".format(a.endswith(b)))
print("")
print("a是否以c为开头：{}".format(a.startswith(c)))

Help on method_descriptor:

startswith(...)
    S.startswith(prefix[, start[, end]]) -> bool
    
    Return True if S starts with the specified prefix, False otherwise.
    With optional start, test S beginning at that position.
    With optional end, stop comparing S at that position.
    prefix can also be a tuple of strings to try.


a是否以b为结尾：True

a是否以c为开头：True

str内置函数

• 操作类函数
  • format：格式化用
  • strip：这个函数主要作用是删除字符串两边的空格【实际可以指定删除字符串两边的任意字符，只不过默认是空格】同时还有lstrip和rstrip，分别表示删除左边右边的字符
  • join：字符串拼接函数

a = "abc def ghijk "
print(a,end="***")
print()
print(a.strip(),end="***")

print()
print("---------分割线----------")

b = "***abc def ghijk*****"
print(b.strip("*"))

abc def ghijk ***
abc def ghijk***
---------分割线----------
abc def ghijk

# join拼接示例
s1 = "*"
s2 = " # "    #一个空格
s3 = "  @  "  #两个空格
s4 = ["abc","def","ghijk"]
print(s1.join(s4))
print(s2.join(s4))
print(s3.join(s4))

abc*def*ghijk
abc # def # ghijk
abc  @  def  @  ghijk