前言回顾
1.列表
- 数据:[元素1, 元素2, 元素3...] - 元素是任何类型的数据
- 特点:可变、有序
- 支持的相关操作: append, insert, extend(将字符串2添加进字符串1), reverse(反转list), +, *, ==, !=, in/not in, len(), list()
- 什么时候使用:需要保存的多个数据是相同性质的数据，例如：保存多个学生的成绩、保存多个学生的信息
2.元组
数据:(元素1, 元素2, 元素3...) --- 元素是任何类型的数据
(元素,)
元素1, 元素2,... = 元组
元素1, *元素2,... = 元组特点:不可变，有序
支持的相关操作: +, *, ==, !=, in/not in, len(), tuple()
什么时候使用: 存储数据的时候一般不主动使用元组，主要是在使用函数的过程中经常遇到元组
3.字典
- 数据: {键1:值, 键2:值2,...} - 键：不可变、唯一 值：任何类型的数据
- 特点: 可变，无序
- 支持的相关操作: ==, !=, in/not in, len(), dict()
- 什么时候使用: 同时存储的多个数据需要区分(性质不同)
4.集合
- 数据: {元素1, 元素2, 元素3,...} -- 元素不可变、唯一
- 特点: 可变、无序
- 支持的相关操作: 数据集合运算(|、&、-、^对称差分)、in/not in、len()、set(序列)(序列中的元素不可变)
- 什么时候使用: 去重、对数据的处理涉及到数学集合运算
补充: is的使用
== 和 is的区别 : 都是判断两个数据是否相等，==判断值是否相等，is判断地址是否相等
python中所有的变量都是保存的数据在内存中的地址；
用一个变量给另一个变量赋值，实质将变量中存储的地址赋过去；
使用变量实质是使用变量中地址对应的内存区域中的值
==：判断两个变量中地址对应的[值]是否相等
is：判断两个变量存储的地址是否相等
list1 = [1, 2]
list2 = [1, 2]
print(id(list1), id(list2))
print(list1 == list2) # True
print(list1 is list2) # False
list3 = list1
print(list1 == list3) # True
print(list1 is list3) # True
# isinstance(object, classinfo) # 判断一个对象的变量类型
函数
引入函数
不使用函数存在的问题：
- 同样的代码需要写多次(冗余)
- 功能发生改变需要修改多次
1.什么是函数
函数就是对实现某一特定功能的代码块的封装
2.函数的分类
- 系统函数(内置函数) - 系统已经实现的函数，只需调用即可
print函数、input函数、len函数、sum函数、max函数 - 自定义函数 - 程序员自己声明的函数(非系统函数)
可以是个人，也可以是一个团体或者组织
nums1 = [100, 23, 6, 78]
print(max(nums1))
# max1 = nums1[0]
# for num in nums1:
# if num > max1:
# max1 = num
# print(max1)
3.函数的声明(定义) - 封装
- 语法：
def 函数名(形参列表):
函数说明文档
函数体
- 说明
def - python声明函数的关键字
函数名 - 要求是标识符不能是关键字(和变量名要求一样)
见名知义：函数名和函数的功能联系
() - 固定写法
形参列表 - 变量名1，变量名2，变量名3...(根据情况变量名的个数可以是0个或者多个)
形参的作用是将函数外面的数据传递到函数的里面
: - 固定写法
函数体 - 和def保持一个缩进的一条或者多条语句(实现函数功能的代码块)
- 初学者声明函数的步骤
第一步：确定函数的功能
第二步：根据功能确定函数名
第三步：确定形参(看实现函数的功能需不需要从外面传值，如果需要传值需要几个)
第四步：实现函数的功能
第五步：确定返回值
(!!!)注意:函数声明的时候，函数体不会执行！
写一个函数来求两个数的和
def sum_1(num1, num2):
"""
函数说明文档(功能说明)
:param num1: # 参数说明
:param num2: # 参数说明
:return: # 返回值说明
"""
print('求和')
print(num1, num2)
声明一个函数，实现求1+2+3+...+n的功能
def sum_2(n):
result = 0
for item in range(1, n+1):
result += item
print(result)
4.函数的调用 - 使用
- 语法
函数名(实参列表)
2）说明
函数名 - 已经声明过的函数
() - 固定写法
实参列表 - 数据1,数据2,数据3...(实参是用来给形参赋值)
- 函数调用过程(特别重要！！)
第一步：回到函数声明的位置
第二步：用实参给形参赋值(这个过程又叫传参，传参要保证每个形参都有值)
第三步：执行函数体
第四步：获取返回值
第五步：回到函数调用的位置，接着往后执行
# 同一个函数可以调用多次
n = int(input('请输入N：'))
sum_2(n)
sum_2(5)
1.位置参数和关键字参数
调用函数时候根据实参的写法分为位置参数和关键字参数
- 位置参数：让实参的顺序和形参一一对应，中间用逗号隔开
- 关键字参数：以'形参名1=值1，形参名2=值2...'格式来确定实参
注意：如果既有位置参数又有关键字参数，位置参数必须写在关键字参数前面
def func1(a, b, c):
print('a:', a, 'b:', b, 'c:', c)
# 位置参数
func1(10, 20, 30)
# 关键字参数
func1(c=30, b=20, a=10)
# 位置参数+关键字参数
func1(10, c=30, b=20)
# func1(c=30, 20, a=10) # SyntaxError: positional argument follows keyword argument
# 其他例子
print(10, 20, 30, sep=',', end='\n')
2.参数默认值
声明函数的时候，可以给形参赋默认值 有默认值的形参，在调用函数的时候可以不用给这个形参赋值
注意：声明的时候，有默认值的参数必须放在没有默认值的参数的后面
def func2(a, b=2, c=30):
print(a, b, c)
func2(100)
func2(100, 200)
func2(100, 200, 300)
# 调用函数只给a和c赋值，b使用默认值
func2(a=100, c=300)
func2(100, c=300)
3.参数的类型说明
python中类型只有说明的作用，没有约束的作用
- 参数赋默认值
- 参数名：类型
def func3(nums: list, a: int, b=''): # :之后为参数类型提示
nums.append(a)
print(nums, a, b)
func3([1, 2], 20, 'bdc')
func3([1, 2], 100)
# from socket import socket
# sever = socket()
# def func(s:socket):
# s.send()
4.不定长参数 - 形参的参数不确定
- [args]声明函数的时候，在形参的前面加，那么这个参数就变成不定长参数，可以同时接受多个位置实参(将这个参数变成元组)
- [kwargs]声明函数的时候，在形参的前面加，那么这个参数也会变成不定长参数,可以同时接收多个关键字实参(将这个参数变成字典)
注意：不带的参数要放在带参数的前面
def func4(*nums):
print('===*不定长参数===')
print(nums)
func4(17, 23)
def func5(aa, **nums):
print('===**不定长参数===')
print(aa, nums)
func5(100, a=10, b=20, c=30, name='bob')
def func6(*args, **kwargs):
print('===*不定长参数+**不定长参数===')
print(args, kwargs)
func6(12, 34, 56)
func6(a=100, b=200)
func6(11, 22, 33, a=100, b=200, c=300)
练习：写一个函数，求多个数的和。要求既可以用位置参数传参，又可以使用关键字参数传参
def func7(*args, **kwargs):
"""
求多个数的和
:param args: 不定长参数，接收多个位置实参，实参为数字
:param kwargs: 不定长参数，接收多个关键字实参，实参为数字
:return: None
"""
fun_sum = 0
for item in args:
fun_sum += item
for key in kwargs:
fun_sum += kwargs[key]
print(fun_sum)
func7(1, 3, 4, a=2, b=1)
写一个函数，求多个数的和
def my_sum(a, *nums, b=0):
print(a, nums, b)
# my_sum()
my_sum(1) # a=1, nums=()
my_sum(23, 10) # a=23, nums=(10,)
my_sum(10, 29, 25)
练习：写一个函数，按指定的方式计算多个数字的结果
operation('+',23,34,45,56) -> 求和
operation('-',23,34,45,56) -> 求差 23-34-45-56
operation('',23,34,45,56) -> 求积 23344556
operation('/',23,34,45,56) -> 求商 23/34/45/56
def operation(f: str, *nums):
if f == '+':
res = 0
for item in nums:
res += item
print(res)
elif f == '-':
res = nums[0]
for item in nums[1:]:
res -= item
print(res)
elif f == '*':
res = 1
for item in nums:
res *= item
print(res)
elif f == '/':
res = nums[0]
for item in nums[1:]:
if item == 0:
print('除数不能为0')
exit(0)
for item in nums[1:]:
res /= item
print(res)
else:
print('请输入运算符')
operation('+', 23, 34, 45, 56)
operation('-', 23, 34, 45, 56)
operation('*', 23, 34, 45, 56)
operation('/', 23, 34, 45, 56)
1.什么是函数的返回值
返回值就是return关键字后面表达式的值，就是函数调用表达式的值
- return
return是函数体中的关键字(只能出现在函数体)
作用：结束函数，确定函数返回值
调用函数：执行函数体，获取返回值
(重要！！！)函数调用过程
1.回到函数声明的位置
2.传参
3.执行函数体
4.执行完函数体，确定函数返回值
执行完函数体：函数体执行完；执行过程中遇到return
确定函数返回值：看执行函数的过程中有没有遇到return，如果遇到了return后面的表达式的值就是函数的返回值
如果没有return，函数的返回值就是None
5.回到函数调用的位置，接着往后执行 (这个时候函数调用表达式的值就是函数的返回值)
def func1():
print('=====')
# return # 函数体遇到return，函数提前结束，不会执行return之后的函数体
print('hello')
a = 100
if a > 1000:
return a+23 # 确定函数返回值
# return: None
a = func1() # func1 = None
print(a)
a = 10
nums = [10, func1()]
print(nums)
2.什么时候需要返回值(初学者)
指导思想：如果实现函数的功能会产生新的数据，就可以把这个数据作为函数返回值
return 返回值1，返回值... (多个返回值是返回一个元组(当然默认是元组，也可以返回列表))
def my_sum(num1, num2):
return num1+num2
# print(num1+num2)
# return和print区别，print只是将数据打印出来，而return能获取函数的返回值并对其操作
sum1 = my_sum(10, 20)
print(sum1)