函数基础
review
1.python中三个单引号或者三个双引号引起来的也是字符串，这种字符串在字符串内部可以直接按回车对字符串进行换行
2.字符
\n, \t, \, ', "
\u4e00
r语法
3.获取字符
4.相关操作: +, *, >, <, >=, <=, ==, !=,in/not in, len, str, sorted
5.相关方法: split, join, count, replace, zfill...
str1 = 'abc'
str2 = "abc\n123"
str3 = '''abc
123'''
str4 = """a
bc
12
3
homework
3.输入用户名，判断用户名是否合法(用户名中只能由数字和字母组成)
例如: 'abc' — 合法 '123' — 合法 ‘abc123a’ — 合法
name = input('请输入用户名:')
for char in name:
if not ('a' <= char <= 'z' or 'A' <= char <= 'Z' or '0' <= char <= '9'):
print('不合法')
break
else:
print('合法')
4.输入用户名，判断用户名是否合法(用户名必须包含且只能包含数字和字母，并且第一个字符必须是大写字母)
例如: 'abc' — 不合法 '123' — 不合法 'abc123' — 不合法 'Abc123ahs' — 合法
name = input('请输入用户名:')
# 先判断第一个字符是否是大写大写
if 'A' <= name[0] <= 'Z':
count = 0 # 统计后面数字字符的个数
for char in name[1:]:
# 判断是否出现不合法的字符
if not ('a' <= char <= 'z' or 'A' <= char <= 'Z' or '0' <= char <= '9'):
print('不合法')
break
else:
# 如果字符合法再看这个合法的字符是否是数字字符
if '0' <= char <= '9':
count += 1
# 如果后面全是合法字符
else:
# 看后面是否有数字
if count >= 1:
print('合法')
else:
print('不合法')
else:
print('不合法')
5.输入一个字符串，将字符串中所有的数字字符取出来产生一个新的字符串
例如：输入'abc1shj23kls99+2kkk' 输出：'123992'
new_str = ''
str1 = 'abc1shj23kls99+2kkk'
for char in str1:
if '0' <= char <= '9':
new_str += char
print(new_str)
6.输入一个字符串，将字符串中所有的小写字母变成对应的大写字母输出 (用upper方法和自己写算法两种方式实现)
例如: 输入'a2h2klm12+' 输出 'A2H2KLM12+'
str2 = 'a2h2klm12+'
new_str = ''
for char in str2:
if 'a' <= char <= 'z':
new_str += chr(ord(char) - 32)
else:
new_str += char
print(new_str)
- 输入一个小于1000的数字，产生对应的学号
例如: 输入'23'，输出'py1901023' 输入'9', 输出'py1901009' 输入'123'，输出'py1901123'
width = 3
num = input('输入编号(0-999):')
num_str = 'py1901' + (width - len(num)) * '0' + num
print(num_str)
- 写程序实现字符串函数find/index的功能(获取字符串1中字符串2第一次出现的位置)
例如: 字符串1为:how are you? Im fine, Thank you! , 字符串2为:you, 打印8
str1 = 'how are y7ou? Im fine, Thank you!'
str2 = 'you'
length = len(str2)
for index in range(len(str1)-length+1):
temp = str1[index: index + length]
if temp == str2:
print(index)
break
else:
print(-1)
函数概论
1.什么是函数
函数就是对实现特定功能的代码的封装
2.函数的分类
系统函数(内置函数) - 系统已经声明好的函数(类似已经造好的机器)，程序员会用就行,
例如: print\input\sum\max\hex\len\id\type等...
自定义函数 - 程序员自己声明的函数(自己造机器)
3.声明函数(造机器)
1)语法:
def 函数名(形参列表):
函数说明文档
函数体
2)说明:
def - python中声明函数的关键字(固定写法)
函数名 - 和变量名的要求一样
(): - 固定写法
形参列表 - 以'变量名1,变量名2,变量名3,...'的形式存在；每个变量就要形参。
形参的个数根据情况可以没有也可以有多个。
形参的作用是将函数外面的数据传递到函数里面
函数说明文档 - 用三个双引号引来的字符串；作用是对函数的功能进行说明
函数体 - 和def保持一个缩颈的一行或者多行语句。（实现函数功能的多条语句）
3)初学者声明函数的步骤
a.确定函数的功能
b.根据函数功能确定函数名
c.确定函数的参数: 看实现函数的功能需不需要从外面传值，需要几个？
d.实现函数的功能
注意(重要!!!!): 声明函数的时候不会执行函数体
写一个函数，求两个数的和并且打印
def sum1(num1, num2):
"""
函数功能说明部分 - 求和
:param num1: 参数说明， 数字1
:param num2: 参数说明， 数字2
:return: 返回值说明
"""
print('=======')
print(num1 + num2)
print('~~~~~~')
4.函数的调用（调用函数相当于使用机器）
1)语法
函数名(实参列表)
2)说明
函数名 - 已经声明过的函数的函数名
() - 固定写法
实参列表 - 以'值1, 值2, 值3,...'形式存在; 这儿的每个值就叫实参；
实参是用来给形参赋值的
sum1(10, 20)
sum1(10) # TypeError: sum1() missing 1 required positional argument: 'num2'
sum1(10, 20, 30) # TypeError: sum1() takes 2 positional arguments but 3 were given
同一个函数可以调用多次
sum1(100, 300)
函数的调用
1.函数调用过程
1）语法
函数名(实参列表)
2)调用函数的作用: 执行函数体；获取返回值
3)函数调用过程(非常重要!!!!):
第一步: 回到函数声明的位置
第二步: 传参(用实参给形参赋值)
第三步: 执行函数体
(第四步: 执行完函数体就确定返回值)
第五步: 回到函数调用的位置接着往后执行
声明一个函数，实现求1+2+3+...+N的和
def sum1(n):
# n = 10; n=100
t = 0
for num in range(1, n+1):
t += num
print(t)
sum1(10)
sum1(100)
声明一个函数，实现求m+m+1+m+2+...+N的和
def sum2(m, n):
# m=10, n=100
# m=1, n=9
print('m: %d, n:%d' % (m, n))
t = 0
for num in range(m, n+1):
t += num
print(t)
sum2(10, 100)
sum2(1, 9)
声明一个函数，打印字符串中所有的字母字符
def print_alpha(str1):
# str1 = 'how are 123 y 90!'
new_str = ''
for char in str1:
if 'a' <= char <= 'z' or 'A' <= char <= 'Z':
new_str += char
print(new_str)
print_alpha('how are 123 y 90!')
声明一个函数，在指定的字符串中数字字符后都添加一个指定的字符
'abc123', '' -> 'abc123'
'h2wo4end', '=' -> h2=wo4=end
def append_char(str1, char):
# str1 = 'abc123', char = '*'
new_str = ''
for x in str1:
if '0' <= x <= '9':
new_str += x + char
else:
new_str += x
print(new_str)
append_char('abc123', '*')
函数的参数
1.位置参数和关键字参数(针对实参)
根据调用函数的时候传参的方式将参数分别位置参数和关键字参数
1)位置参数: 让实参和形参在位置上一一对应(第一个实参给第一个形参赋值，第二个实参给第二个形参赋值...)
2)关键字参数: 以'形参名=值'的形式传参
注意: 位置参数和关键字参数可以一起使用，但是一起用的时候要求位置参数必须在关键字参数的前面
3)什么时候使用关键字参数：需要跳过前面某个或者某几个参数，直接给后面某个参数赋值的时候必须使用关键字参数
def func1(a, b, c):
# a=10,b=20,c=30
print('a:{}, b:{}, c:{}'.format(a, b, c))
# 位置参数传参
func1(10, 20, 30)
# 关键字参数传参
func1(a=100, b=200, c=300)
func1(b=200, c=300, a=100)
# 位置参数和关键字参数同时使用
func1(10, b=20, c=30)
func1(10, c=30, b=20)
2.参数默认值（形参）
声明函数时候,形参可以设置默认值， 设置完默认值后调用函数的时候有默认值的参数可以不用传参。
一个函数可以给所有的参数都设置默认值，也可以给部分参数设置默认值；必须保证没有默认值参数必须放在有默认值参数的前面
def func2(x=11, y=22, z=33):
print('x:{}, y:{}, z:{}'.format(x, y, z))
func2(100, 200, 300) # x:100, y:200, z:300
func2(100) # x:100, y:22, z:33
func2(100, 200) # x:100, y:200, z:33
func2() # x:11, y:22, z:33
func2(100, z=300) # x:100, y:22, z:300
3.参数类型说明
1)给参数赋默认值, 默认值的类型就是参数的类型
2)以'参数名:类型名'的形式声明函数
def func3(a: int, b: str, c=10):
print('a:{}, b:{}, c:{}'.format(a, b, c))
print(a % 10, c % 20)
# func3(90, 'qwe', [12, 45])
def func4(x: list):
# x.append(100)
x.append(100)
4.不定长参数
1)在形参前加，那么这个参数就可以同时接受多个实参(位置参数); 带的参数会作为一个元祖，对应的多个实参是元祖中的元素
2)在形参前加, 那么这个参数也可以同时接受多个实参(关键字参数,关键字自己随便命名);
将带的参数作为一个字典，将关键字参数的关键字作为key实参作为value存储在字典中。
def func(args,*kwargs), 这个函数中 *args 和 **kwargs的作用
"""
写一个函数，计算多个数的和
sum1(1), sum1(2, 45), sum1(2, 4, 5, 6), ....
def func5(*nums):
# nums = (89, 9, 34.8)
print(nums)
print(sum(nums))
func5(89, 9, 34.8)
# func5(a=10, b=20) # 带*的不定长参数，不能使用关键字参数传参
def func6(x, y, *nums):
print(x, y, nums)
func6(1, 2, 3, 4, 5, 6, 7, 100)
def func7(**nums):
print(nums)
func7(a=1, b=2, x=4)
func7(a=1)
*args 和 **kwargs一起用是为了保证不定长参数传参的时候既可以使用位置参数也可以使用关键字参数
def func8(*args, **kwargs):
print(args, kwargs)
func8(1, 23)
func8(a=2, c=90, k=34)
func8(2, 4, x=2, y=89)
# (了解)补充: *的用法: *列表/*元祖 -> 直接取出列表/元祖中所有的元素
# **字典 -> 直接取出字典中的所有元素
list1 = [89, 90, 89]
# *list1 -> 89, 90, 89
print(*list1) # 89 90 89 ->print(89, 90, 89)
def func9(x, y):
print(x, y)
func9(1, 2)
list2 = [10, 20]
func9(*list2)
dict1 = {'a': 1, 'b': 2} # a= 1, b=2
def func10(b, a):
print(a, b)
func10(**dict1)
练习: 声明一个函数，求多个数的差
differ(1, 2) -> -1 differ(10, 2, 3) -> 5 differ(10, 20, 30) -> -40
def differ(*nums):
if not nums:
print(0)
else:
sum1 = nums[0]
for num in nums[1:]:
sum1 -= num
print(sum1)
differ(1, 2)
differ(10, 2, 3)
differ(10, 20, 30)
函数的返回值
1. 什么是返回值
返回值就是return关键字后表达式的值 (怎么确定函数的返回值)
返回值就是函数调用表达式的值 (怎么获取函数的返回值)
(python中所有函数都有返回值，默认是None)
1)什么是return
return是函数体中的关键字(只能在函数中使用), 作用有两个: 结束函数\确定函数返回值
a.结束函数: 执行函数体的时候只要遇到return函数直接结束
b.确定函数返回值: return 返回值(可以是具体的数据，声明过的变量，运算表达式)
2)什么是函数调用表达式
函数调用语句就是函数调用表达式, 例如: func1(10), max([1, 2]),
每个调用函数的语句都有结果，这个结果就是调用这个函数得到的返回值
def func1():
for x in range(10):
if x == 2:
return
print(x)
print('里面: 函数结束')
print('func1:', func1())
def func2():
print('=====')
return
print('++++++')
print('------')
print('func2:', func2())
def func3():
if False:
return 10
print('func3:', func3())
def func4():
return 100
print('func4:', func4())
2.怎么使用返回值
想要用函数的返回值，就使用函数调用表达式的值。
普通数据能做的事情，函数调用表达式都可以做
100
func4()
num = 100
num1 = func4()
print(num, num1)
list1 = [100, 200]
list2 = [func4(), 200]
print(list1, list2)
print(100 > 200, 100 * 2)
print(func4() > 200, func4()*2)
3.什么时候需要返回值
初学者：看实现函数的功能会不会产生新的数据
return 返回值1,返回值2,...
def sum1(num1, num2):
return num1 + num2
re = sum1(10, 20)
print(re)
list1 = [re, 20]
