每日反馈

当我们调用函数或方法时,按住ctrl键将鼠标悬停函数或方法上方,系统会提示函数的基本信息,如果再->后有数据类型,则需要接收,如果->后是None 则不需要变量接收

Day05知识回顾

0-今日课程内容

1. 列表
   1. 推导式
2. 元组
   1. 元组的特性
3. 集合
   1. 集合的特性
4. 字典
   1. 字典的增
   2. 字典的删
   3. 字典的改
   4. 字典的查
   5. 字典的遍历
5. 公共方法
   1. 公共方法
   2. 公共函数

01-推导式[熟练使用]

• 在学习初期,我们先书写for形式,并改写为推导式,如果熟练使用了,可以直接书写 ```python

  推导式: 按照一定的规则快速生成一个容器的方法

  列表推导式: 按照一定的规则快速生成一个列表的方法

  格式: 变量 = [要插入列表中的数据 for 临时变量 in 容器] 按照指定的循环规则生成列表

  格式2: 变量 = [要插入列表中的数据 for 临时变量 in 容器 if 条件] 循环后进行条件判断,满足条件插入到列表中,快速生成列表

需求1: 创建一个列表,内部元素时从0-9的数字

for

list1 = [] for i in range(10): list1.append(i)

print(‘for’, list1)

推导式

list2 = [i for i in range(10)]

print(‘推导式’, list2)

需求2:创建换一个列表,内部是从0-9的偶数

for

list3 = [] for i in range(10): if i % 2 == 0: list3.append(i)

print(‘for’, list3)

推导式

list4 = [i for i in range(10) if i % 2 == 0]

print(‘推导式’, list4)

需求3: 创建一个列表, 列表内的内容是[‘传智1.jpg’,’传智2.jpg’…..’传智10.jpg’]

for

list5 = [] for i in range(1, 11): list5.append(f’传智{i}.jpg’)

print(‘for’, list5)

推导式:

list6 = [f’传智{i}.jpg’ for i in range(1, 11)]

print(‘推导式’, list6)

需求4: 创建一个列表,内部存放0-100之前的不是7 或7的倍数, 内部也不含有7 的数字

for

list7 = [] for i in range(101):

# 不是7或7的倍数
if i % 7 != 0:
    # 数字中不含有7
    if str(i).count('7') == 0:
        list7.append(i)

print(‘for’, list7)

推导式:

list8 = [i for i in range(101) if i % 7 != 0 if str(i).count(‘7’) == 0]

print(‘推导式’, list8)

![image.png](https://cdn.nlark.com/yuque/0/2022/png/1280980/1657073754643-e5c82216-42ee-4b71-9adb-f9e5095821b6.png#clientId=u99d65e49-dee3-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=524&id=uc3aaa8bb&margin=%5Bobject%20Object%5D&name=image.png&originHeight=786&originWidth=1276&originalType=binary&ratio=1&rotation=0&showTitle=false&size=199856&status=done&style=none&taskId=u765cd3e0-409f-44ac-9cf5-62ebdc49216&title=&width=850.6666666666666)<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/1280980/1657074126245-972356ac-4980-430d-948d-f2985ea7b87b.png#clientId=u99d65e49-dee3-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=549&id=u3cad7d2a&margin=%5Bobject%20Object%5D&name=image.png&originHeight=824&originWidth=1312&originalType=binary&ratio=1&rotation=0&showTitle=false&size=210552&status=done&style=none&taskId=u8e18a1fa-25ed-4d29-835f-8e6191fd547&title=&width=874.6666666666666)<br />练习: 

1. 快速生成一个列表,列表内是1-10 的平方.
1. 生成一个列表,列表内数据是['视频1.mp4', '视频2.mp4'.....'视频10.mp4']
```python

# 练习
# 1. 快速生成一个列表,列表内是1-10 的平方.
list9 = [i**2 for i in range(1, 11)]
print(list9)

# 2. 生成一个列表,列表内数据是['视频1.mp4', '视频2.mp4'.....'视频10.mp4']
list10 = [f'视频{i}.mp4' for  i in range(1,11)]
print(list10)

# 推导式缺陷:
# 1.推导式可读性差,如果推导式的结构过于复杂,很难阅读.
# 2.推导式中没有办法完成复杂的逻辑处理,以及数据处理,只能根据循环规则和判断规则,进行简单的数据处理.
# 3.推导式中不能定义变量及函数等.

# 注意:推导式和for循环只生成列表的情况下可以转换,绝大多数情况不能相互转换

02-元组的定义[了解]

元组定义时一定有逗号

# 元组的操作方式基本上和列表一致,但是由于元组中的元素时不可以修改的,所以元组的操作方式中没有增删改,只能查询
# 元组的定义
# 格式: 变量 = (元素1, 元素2.....)
tuple1 = (1, 2, 3)
print(tuple1)  # (1, 2, 3)
print(type(tuple1))  # <class 'tuple'>

# 创建一个空元素元组
# 格式: 变量 = ()
tuple2 = ()
print(tuple2)  # ()
print(type(tuple2))  # <class 'tuple'>

# 创建一个单元素元组
# 如果再基础数据类型外套一层小括号,意思是提升算数运算符的优先级,所以数据类型不变
# tuple3 = (1)
# print(tuple3) # 1
# print(type(tuple3)) # <class 'int'>

# 如果要定义单元素元组,需要在元素后添加逗号
# 格式: 变量 = (元素,)

tuple3 = (1,)
print(tuple3)  # (1,)
print(type(tuple3))  # <class 'tuple'>

# 注意:当我们定义元组时,最外层的小括号可以省略,系统会帮我们自动添加
tuple4 = 1, 2, 3, 4
print(tuple4)  # (1, 2, 3, 4)
print(type(tuple4))  # <class 'tuple'>

tuple5 = 10,
print(tuple5)  # (10,)
print(type(tuple5))  # <class 'tuple'>

# tuple内部也可以存放多种数据类型的数据
tuple6 = (1, 'abc', False)
print(tuple6)

03-元组的特性[熟悉]

# 元组的特性: 元组中的数据是不可以被修改的
tuple1 = (1, 2, 3)
# 元组中获取数据可以使用索引值,与列表完全一致
print(tuple1[0])
print(tuple1[1])
print(tuple1[2])

# 元组中使用索引值获取数据时,索引必须存在,否则报错
# IndexError: tuple index out of range
# print(tuple1[5])

# 尝试修改元组中的元素
# 当前元组中的数据不能够被修改,强行修改将会报错
# TypeError: 'tuple' object does not support item assignment
# tuple1[2] = 10

tuple1 = (5, 6, 7)

# 给元组变量重新赋值时被允许的,只是不能修改元组内部的元素而已
print(tuple1)

# 元组中也可以使用切片操作,因为切片时产生了新的数据容器,并没有在源数据上修改
print(tuple1[:1])  # (5,)
print(tuple1)  # (5, 6, 7)

04-元组的常用方法[了解]

# 元组没有增删改的方法,元组只能查询
tuple1 = (1, 2, 3, 4, 5, 4, 3)
# 1.通过索引进行查询
print(tuple1[2])  # 3

# 2.index()
# 查询指定元素在元组中的位置,返回从左至右第一次出现位置的正数索引,如果不存在则报错
# 格式:变量 = 元组.index(元素)
# 需求:获取3 对应的索引值是多少
print(tuple1.index(3))  # 2
# AttributeError: 'tuple' object has no attribute 'find'
# print(tuple1.find(3))

# 3.count()
# 查询指定的元素,在元组中 出现的次数
# 格式: 变量 = 元组.count(元素值)
# 需求: 获取变量4出现的次数
print(tuple1.count(4))  # 2

# 4.len()
# 获取元组中元素的个数,或者说获取元组的长度
print(len(tuple1)) # 7
print(tuple1.__len__()) # 7

# 5.遍历(元组的遍历方法与list完全一致)

# for
for i in tuple1:
    print(i)

# while
i = 0
while i < len(tuple1):
    print(tuple1[i])
    i += 1

05-集合(补充)[了解]

# 集合: 集合也是一个数据容器,内部可以存储大量数据,但是由于期无序,不重复的特性,正常业务开发中使用比较少.

# 集合的定义:
# 格式: 变量 = {元素1, 元素2,......}
set1 = {1, 2, 3, 4}
print(set1)  # {1, 2, 3, 4}
print(type(set1))  # <class 'set'>

# 如果我需要定义一个空集合 需要怎么做??  不能使用{}定义空集合,这是空字典的意思
# set2 = {} 
# print(type(set2))  # <class 'dict'> set2 是字典类型数据

set2 = set()
print(set2)  # set()
print(type(set2))  # <class 'set'>

# 集合特性:
# 无序:
# 强调:在开发中,程序员没有办法控制顺序,我们就称其为无序
name_set = {'Tom', 'Rose', 'Jack', 'Bob'}
print(name_set)  # {'Bob', 'Rose', 'Jack', 'Tom'}  {'Jack', 'Tom', 'Bob', 'Rose'}

# 存入集合中的数据,顺序发生了变化,甚至每一次运行代码,元素顺序都不一样
# 由于其无序的特性,所以也不能够使用索引获取其内部的数据
# TypeError: 'set' object is not subscriptable
# print(name_set[3])

# print({1, 2, 3, 4})
# print({1, 2, 3, 4})
# 1234在集合中的顺序总是相同的但是我们依然称其为无序,因为顺序不可控

# 不重复:
# 向集合中插入数据时,会自动去重
set1 = {1, 2, 3, 4, 4, 3, 2, 5}
print(set1)  # {1, 2, 3, 4, 5}

# 在set中插入数据时, False 和 0   True 和 1 值相同,同时插入时会进行去重

print({1, 2, 3, False, True, 0}) # {False, 1, 2, 3}

# 集合在使用的时候不能使用索引获取内部的元素,所以想要获取只能通过类型转换或者遍历

# 遍历
for name in name_set:
    print(name)

06-集合中存放数据的要求[了解]

集合内不能存放 集合, 列表,字典数据

# set中保存的数据不能是 集合, 列表, 字典

set1 = {1, 11.2, 'chuanzhi', (1, 2, 3), False}
# 结论: 在集合中可以存放int , float, bool, str, tuple
print(set1)

# 列表
# TypeError: unhashable type: 'list'
# 不能存放列表数据
# set1 = {[1, 2]}

# 集合
# TypeError: unhashable type: 'set'
# 不能存放集合数据
# set1 = {{1, 2}}

# 字典
# TypeError: unhashable type: 'dict'
# 集合内不能存放字典类型数据
# set1 = {{'a': 1}}

# 结论: 集合类型数据内部不能存放可变数据类型(讲完字典后会讲)

07-字典的定义及特性[熟练使用]

字典时程序员快速存取数据的工具,如果不能快速存取,可以使用其他数据类型(存储相同的数据字典占用空间最大)

# 字典这个容器是用来帮助程序员快速存取数据的
# 字典中是以键值对来存储数据的,一个键对应一个值,键不能重复

# 类比: 列表时系统自动赋予的一个数字索引,字典就是程序员自己定义索引的容器,键就相当于索引
# 索引值不能重复,所以键也不能重复, 每一个索引对应一个唯一的值, 每一个键也对应一个唯一的值

# 字典的定义
# 格式: 变量 = {键1:值1, 键2:值2.....}
stu_dict = {'name': 'Tom', 'age': 18, 'gender': '男'}
print(stu_dict)  # {'name': 'Tom', 'age': 18, 'gender': '男'}
print(type(stu_dict))  # <class 'dict'>

# 定义一个空字典
dict_temp = {}
print(dict_temp)  # {}
print(type(dict_temp))  # <class 'dict'>

# 特性:
# 1.字典中不能有相同的键,如果存在,则保留最后一个键对应的值,值可以重复
dict1 = {'name': 'xiaoming', 'age': 18, 'name': 'xiaohong', 'money': 50, 'name': 'xiaomei'}

print(dict1)  # {'name': 'xiaomei', 'age': 18, 'money': 50}

# 2.字典中的键值对是成对出现的,不能单独出现键,也不能单独出现值
# SyntaxError: invalid syntax
# print({'name': 'xiaomei', 'age': 18, 'money': 50, 'name':})

# 3.字典无法使用索引,对于程序员来说,字典中键值对的顺序无法修改和利用,所以我们将其看做时无序的
# KeyError: 2
# print(dict1[2])

# 4.字典要使用键获取值, 如果我们发现某个需求需要我们使用值获取键,则证明逻辑错误
dict2 = {'name': 'Tom', 'age': 18, 'gender': '男'}
print(dict2['name'])  # Tom
print(dict2['age'])  # 18
print(dict2['gender'])  # 男

# 注意: 如果我们忘记了键怎么取值呢? 起名时就要见名知意,方便记忆,否则忘记了键就无法快速取值了,如果只能遍历取值就不如使用列表了
# 一般情况下,键都是对于值的解释,值是键的具体内容

# 键可以用中文,但是不要用,因为服务和编程语言对于中文都不是很友好,可能会出现稀奇古怪的问题

练习: 使用字典保存自己的个人信息 姓名 年龄 身高 体重 性别

08-字典增和改的操作[熟练使用]

字典在使用过程中,最需要注意的问题就是修改键所对应的值时,写错了不报错,而是产生了一个新的键值对,非常容易出错

# 增--向字典中增加新的键值对
# 改--修改字典中键所对应的值

# 定义一个字典
dict1 = {'name': '小明', 'age': 18}

# 1.使用dict[新键] = 值 的方法增加新的键值对, 如果键存在,则是修改键所对应的值
# 我们可以通过给新的键赋值的形式增加新键值对
# 需求: 新增一个性别键值对, 性别:女
dict1['gender'] = '女'
# 如果写的键不存在,就是新增键值对
print(dict1)  # {'name': '小明', 'age': 18, 'gender': '女'}

# 需求: 将name键所对应的值改为小红
# 如果键存在就是修改原键所对应的值
dict1['name'] = '小红'
print(dict1)  # {'name': '小红', 'age': 18, 'gender': '女'}

# 2.update
# update就是更新字典中的键值对, 如果更新的键不存在,则为新增
# 格式: 字典.update({'键1':值1, '键2':值2...})

# 需求: 新增两个键值对, 性别  身高
dict2 = {'name': '小明', 'age': 18}
dict2.update({'gender': '男', 'height': 178.33})
print(dict2)  # {'name': '小明', 'age': 18, 'gender': '男', 'height': 178.33}

# 需求2: 修改身高和性别两个键所对应的值
dict2.update({'gender': '女', 'height': 165.22})
print(dict2) # {'name': '小明', 'age': 18, 'gender': '女', 'height': 165.22}

# 更新字典中的数据,和使用新键一样,如果键不存在,就是新增键值对,如果键存在,就是修改键所对应的值

09-字典删的操作[熟练使用]

# 删除的是键值对
# 定义一个字典
dict1 = {'name': '小明', 'age': 18, 'gender': '女', 'height': 165.22}

# 删除的方法
# 1. pop
# 根据键删除键值对,如果被删除的键不存在,则报错,会将被删除的键所对应的值进行返回
# 键:值 >>>>  key : value
# 格式: 字典.pop(键)
# 需求: 删除键'name'所对应的键值对
value = dict1.pop('height')
print(dict1)  # {'name': '小明', 'age': 18, 'gender': '女'}
print(value)  # 165.22

# KeyError: 'weight'  pop删除时,所对应的键必须在字典中存在,否则报错
# dict1.pop('weight')

# 2. popitem  删除最后插入的键值对, 并且将该键和值组成的元组进行返回
item = dict1.popitem()
print(dict1)  # {'name': '小明', 'age': 18}
print(item)  # ('gender', '女')

# dict1.popitem()
# dict1.popitem()
# dict1.popitem()
# KeyError: 'popitem(): dictionary is empty'
# 如果被删除的字典为空会报错
# print(dict1)

# 3.clear
# 清空字典,得到一个空字典
dict1.clear()
print(dict1)  # {}

# 4.del  del也必须通过键删除键值对
# del dict1['name']
# print(dict1)

10-字典的查找操作[熟练使用]

查找时只能使用键找值,如果需要值查询键则可以重新设计代码逻辑了.

# 字典中查询信息的方式是用键查值
dict1 = {'name': '小明', 'age': 18, 'gender': '女', 'height': 165.22}

# 1.根据键查询值
print(dict1['name'])  # 小明
print(dict1['age'])  # 18
# 注意: 查询时,字典的键必须存在,否则报错
# KeyError: 'id'
# print(dict1['id'])

# 2.使用更加安全的方式获取键所对应的值  get
# 如果通过键获取值,键不存在则报错,如果使用get则不会
print(dict1.get('name'))  # 小明
print(dict1.get('age'))  # 18
# 获取一个不存在的键对应的值, 不会报错,而是返回应None
print(dict1.get('id'))  # None

# 拓展: 当获取的键不存在时,我们也可以设置默认值
print(dict1.get('name', '该键不存在'))  # 小明 如果键存在,就返回键所对应的值
print(dict1.get('id', '该键不存在'))  # 该键不存在 如果键不存在,就返回默认值

# 注意:在获取数据时,建议使用get但是不能使用get赋值
# SyntaxError: cannot assign to function call
# dict1.get('name') = '小美'

# 3.获取字典中所有的键  keys()
# 获取的内容是dict_keys数据类型的容器不是list,但是可以转换为list数据类型使用
print(dict1.keys())  # dict_keys(['name', 'age', 'gender', 'height'])
# TypeError: 'dict_keys' object is not subscriptable
# print(dict1.keys()[0])

# 4.获取字典中所有的值  values()
# 获取的内容是dict_values类型的数据
print(dict1.values())  # dict_values(['小明', 18, '女', 165.22])

# 5.获取字典中所有的键值对 items()
# 获取的内容是dict_items类型的数据,内部元素是键和值组成的元组
print(dict1.items())  # dict_items([('name', '小明'), ('age', 18), ('gender', '女'), ('height', 165.22)])

# 注意: dict_keys,dict_values,dict_items都不能使用索引取值,但是可以遍历

# 6.len 获取的是字典中键值对的数量,或者说字典的长度
print(len(dict1))  # 4

11-字典的遍历操作[熟练使用]

• 字典遍历时要知道自己到底想要键还是值,或者键值对,根据需求选择遍历方法 ```python

  当字典遍历时,建议使用for循环,在之后讲解遍历容器时,就不再考虑while,如果需要,自行进行转换

dict1 = {‘name’: ‘小明’, ‘age’: 18, ‘gender’: ‘女’, ‘height’: 165.22}

1.直接遍历

如果直接对字典进行遍历,则获取到的是字典的key

for key in dict1: print(key)

print(‘——————————‘)

2.可以使用keys()函数进行遍历,获取每一个key的值,和直接遍历效果相同(几乎不用)

for key in dict1.keys(): print(key)

print(‘——————————‘)

3.可以使用values进行遍历,依次获取字典中的每一个值

for value in dict1.values(): print(value)

print(‘——————————‘)

4.可以使用items进行遍历,依次获取字典中每一个键值对组成的元组

for item in dict1.items(): print(item)

print(‘——————————‘)

5.可不可以分开获取键和值呢?可以的,在临时变量位置书写两个变量值即可

for key,value in dict1.items(): print(‘key:’, key) print(‘value:’, value)

遍历字典时,上述方法最常用

练习: 创建一个自己个人信息字典   姓名,年龄,学号,班级

1. 在字典中添加一个身高键值对
1. 删除学号键值对
1. 将班级键值对从79期基础 改为79期就业
1. 将键值对遍历出来
```python
# 练习: 创建一个自己个人信息字典   姓名,年龄,学号,班级
dict1 = {'name': '冀老师', 'age': 18, 'stu_id': '001', 'class': '79期基础'}
# 1. 在字典中添加一个身高键值对
dict1['height'] = 185.5
# 2. 删除学号键值对
dict1.pop('stu_id')
# 3. 将班级键值对从79期基础 改为79期就业
dict1.update({'class': '79期就业'})
# 4. 将键值对遍历出来
for key, value in dict1.items():
    print(key, value, sep=':')

12-可以作为字典的键出现的数据类型[了解]

在开发中几乎我们遇到的键都是字符串,因为方便记忆

# 只有字符串可以作为字典的键出现么?  不是

# 能够添加到集合中的数据,都可以作为字典的键出现

dict1 = {'name': '小明', 12: 'abc', False: '小芳', 11.2: 123, (1, 2, 3): [1, 2, 3]}
# 字典的键可以使用str, int ,float, bool tuple类型
print(dict1)

# 字典的键不能使用list类型
# TypeError: unhashable type: 'list'
# dict2 = {[1, 2, 3]: '111'}

# 字典的键不能使用set类型
# TypeError: unhashable type: 'set'
# dict2 = {{1, 2, 3}: '111'}

# 字典的键不能使用dict类型
# TypeError: unhashable type: 'dict'
# dict2 = {{'a':1} : '111'}

13-公共方法-运算符[熟悉]

# 运算符
# + 在数值型数据中,+号是进行加法运算的,但是在容器中+是用来合并容器,或者说是拼接容器的
list1 = [1, 2, 3]
list2 = [3, 4, 5]
# 使用+运算符,将两个容器拼接到了一起,获得了一个新的容器
print(list1 + list2)  # [1, 2, 3, 3, 4, 5]
print(list1)  # [1, 2, 3]
print(list2)  # [3, 4, 5]

# 除了列表,字符串, 元组也可以进行拼接
print('传智' + '教育')  # 传智教育
print((1, 2, 3) + (4, 5, 6))  # (1, 2, 3, 4, 5, 6)

# 加法运算只能在两个相同类型的数据容器间进行,否则报错
# TypeError: can only concatenate str (not "list") to str
# print('传智' + [1, 2, 3])
# TypeError: can only concatenate list (not "tuple") to list
# print([1, 2, 3] + (3, 4, 5))

# * 在数值型数据中,*号是进行乘法运算的,但是在容器中*是复制指定次数的容器,并进行拼接的
# 使用格式: int类型数据 * 容器  或者 容器 * int类型的数据 否则报错
# 乘法运算结束后,会产生一个新的数据容器,原数据不变
list3 = [1, 2, 3]
# 就是将list3 复制了4份,并使用加法运算拼接到一起
print(list3 * 4)  # [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
print(list3)  # [1, 2, 3]

# 可以进行加法运算的数据类型,都可以进行乘法运算,不能进行加法运算的,也不能进行乘法运算
# 所以 字符串和元组可以进行乘法运算
print('-' * 20)
print((1, 2, 3) * 3)  # (1, 2, 3, 1, 2, 3, 1, 2, 3)

# in / not in
# 判断元素是否在容器中
# 格式: 元素 in 容器 /  元素 not in 容器
# list
print(7 in [1, 2, 3])  # False
print(3 in [1, 2, 3])  # True

# str
print('7' in '123')  # False
print('3' in '123')  # True

# tuple
print(7 not in (1, 2, 3))  # True
print(3 not in (1, 2, 3))  # False

# set
print(7 not in {1, 2, 3})  # True
print(3 not in {1, 2, 3})  # False

# dict
# 使用in 或者not in 判断字典类型数据时,判断的是该元素是否为字典的键
print(7 in {'a': 7})  # False
print('a' in {'a': 7})  # True

# 注意:如果要判断该元素是否在容器中,要确定该元素可以存放在容器内,否则报错
# TypeError: 'in <string>' requires string as left operand, not int
# 7 是int 类型不能存放在str类型数据中,所以不能使用in判断
# print(7 in '123')
# TypeError: unhashable type: 'list'
# print([1, 2] in {1, 2, 3, 4})

14-公共函数[熟悉]

# 公共函数,就是多种容器都可以使用的函数
# 1. len 获取容器的长度,或者说获取容器内元素的个数
list1 = [1, 2, 3, 4]
print(len(list1))  # 4
dict1 = {'name': '小明', 'age': 18, 'gender': '女', 'height': 165.22}
print(len(dict1))

# 2. del  切断数据和变量,或者数据和容器的引用关系
# 只要可以单独获取容器中的元素,就可以使用del进行删除

del (list1[2])
del dict1['name']

print(list1)  # [1, 2, 4]
print(dict1)  # {'age': 18, 'gender': '女', 'height': 165.22}

# 但是遍历时例外
# for 循环时,将list1中的元素赋值给了i  使用del i  其实是切断了i 和数据的引用关系,容器和数据的引用关系没有改变
for i in list1:
    if i == 4:
        del i

print(list1)  # [1, 2, 4]

# 3. max 和 min
# 获取容器中的最大值或者最小值
print(max(list1))
print(min(list1))

# 注意: 获取容器中的数据最大值和最小值时,容器中的数据必须可以比较大小
print(max([1, 2, 5, 6, 3])) # 6
# TypeError: '>' not supported between instances of 'str' and 'int'
# print(max([1, 2, 5, 6, 3, '小明'])) 


# 还有一些常用函数自己去探索尝试
# sum() 求和
# abs() 求绝对值

注意:学习了这么多的方法和函数,不是为了让大家背下来,是让大家学会探索学习这类知识的方法.

15-函数的介绍[了解]

1. 函数就是讲一段具有独立功能的代码打包在一起,当需要调用该功能的时候,我们就将函数进行调用即可
2. 函数中的参数: 还是外部的数据传递到函数内部进行计算或执行的一种手段
3. 函数的返回值: 获取函数内部计算或执行得到的结果的方式

举例:

1. 在工厂进行生产制造的时候,将一个生产过程打包为一条流水线,这个流水线就相当于函数
2. 在流水线上需要从外部向内部添加原材料,这个原材料就相当于参数
3. 流水线生产结束后,会产生一个产品,用于对外销售,这个产品就相当于返回值

   16-函数的简单使用[了解]

   ```python

   我们之前就使用过很多的函数 例如 len print max min input

   总结规律:

   1. 所有的函数都实现了一个特定的功能

   2. 所有的函数都使用了()进行调用

   3. 所有的函数都可以使用变量接收(有些接收后是有数值的, 有些会接收到None)

自定义函数

函数的定义规则 : 使用def关键字构造函数

‘’’ 定义格式: def 函数名(): # 函数名要符合标识符的命名规则,并且见名知意 函数体 : 一般具有完整的功能

调用格式: 函数名(参数) 函数的好处: 可以提高代码的复用率,重复利用多次我们定义的函数,减少代码量 ‘’’

系统函数

print(‘传智播客’)

自定义函数

def print_func(): print(‘hello world!’) print(‘hello python!’) print(‘hello bigdata!’)

调用自定义函数

print_func() print(‘第一次执行成功’) print_func() print(‘不知道要写什么’) print(‘间隔内容不固定’) print_func()

为什么多次使用不使用循环呢?

使用场景不同,循环时连续重复, 函数可以不连续重复使用

<a name="LNngS"></a>
# 17-函数定义时的注意事项[掌握]
```python
# 1.函数要先定义再调用
# NameError: name 'func' is not defined
# func()

def func():
    print('hello world!')


func()  # hello world!


# 2.当重复定义该函数时,后定义的函数功能会覆盖先定义的函数功能

def func():
    print('hello python!')


func()  # hello python!

# 3.如果定义了与函数同名的变量,也会覆盖其功能

func = 1
# TypeError: 'int' object is not callable
# func()
# 此时func已经不具备函数的功能了,只是一个int类型的数据
print(func)  # 1

# 之前我定义变量名时, 累加器 叫做sum1   列表  叫做list1
# 不能直接使用sum 或者list 会覆盖系统函数的功能,导致功能无法使用
# 我们再开发中也要注意定义的函数名称不要与系统函数重名否则会出现问题

作业

06-字典作业.md
06-字典答案.md

作业提交

点击查看【jinshuju】

文件链接

百度云盘: 链接：https://pan.baidu.com/s/13TqhouBQ8h1lP2VFtQHgMw 提取码：lh3d
阿里云盘:「python+大数据79期基础」等文件 https://www.aliyundrive.com/s/G6iPqGFQgfJ