Python

（原本应该好几天前就上传了的😢，前面两次的排版好大问题😭，希望后面越来越好哈）

函数初步

介绍

函数：是组织好的，可重复使用的，用来实现特定功能的代码段。

使用函数原因

• 为了得到一个针对特定需求、可供重复利用的代码段 提高程序的复用性，减少重复性代码，提高开发效率

定义

1. 函数的定义语法

2. 函数使用步骤:

• 先定义函数

• 后调用函数

3. 注意事项：

• 参数不需要，可以省略

• 返回值不需要，可以省略

# 查核酸
def my_fuction():
    print("Welcome to itheima")
    print("Please show your health code and a nucleic acid test result within 72 hours")
my_fuction()

参数

传入参数的功能是：在函数进行计算的时候，接受外部（调用时）提供的数据

1. 注意事项

• 函数定义中的参数，称之为形式参数

• 函数调用中的参数，称之为实际参数

• 函数的参数数量不限，使用逗号分隔开

• 传入参数的时候，要和形式参数一一对应，逗号隔开

# 带参数查核酸
def check_nucleic_acid(temperarture):
    print("Please show your health code and a nucleic acid test result within 72 hours, "
          "and cooperate with the temperature measurement!")
    if temperarture > 37.5:
        print("Quarantine is required.")
    else:
        print("Your temperature is normal. Please come in")

temp = int(input("Please input your temperature: "))
check_nucleic_acid(temp)

返回值

函数返回值的定义

1. 什么是函数返回值？

函数在执行完成后，返回给调用者的结果

2. 返回值的应用语法：

使用关键字：return 来返回结果

3. 注意：

函数体在遇到return后就结束了，所以写在return后的代码不会执行

None类型

思考：如果函数没有使用return语句返回数据，那么函数有返回值吗？-----实际上是：有的。

Python中有一个特殊的字面量：None，其类型是：<class ‘NoneType’>
无返回值的函数，实际上就是返回了：None这个字面量

None表示：空的、无实际意义的意思
函数返回的None，就表示，这个函数没有返回什么有意义的内容。也就是返回了空的意思。

None可以主动使用return返回，效果等同于不写return语句

None作为一个特殊的字面量，用于表示：空、无意义，其有非常多的应用场景:

1. 用在函数无返回值上

2. 用在if判断上

• 在 if 判断中， None 等同于 False

• 一般用于在函数中主动返回 None ，配合 if 判断做相关处理

3. 用于声明无内容的变量上

• 定义变量，但暂时不需要变量有具体值，可以用None来代替

说明文档

掌握通过注释对函数进行解释说明

1. 函数说明文档的作用是？

对函数进行说明解释，帮助更好理解函数的功能

2. 定义语法(在函数内的6单引号中间，＋enter，自动生成说明框架)

•:param 用于解释参数

•:return 用于解释返回值

嵌套调用

所谓函数嵌套调用指的是一个函数里面又调用了另外一个函数
如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置

变量的作用域

变量作用域指的是变量的作用范围（变量在哪里可用，在哪里不可用）
主要分为两类：局部变量和全局变量

局部变量是定义在函数体内部的变量，即只在函数体内部生效
局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量

使用 global关键字 可以在函数内部声明变量为全局变量,

def test1():
    num = 200
    print(f"{num}")
def test2():
    global num
    num = 300
    print(f"{num}")
test1()
print(f"{num}")
test2()
print(f"{num}")

'''
200
100
300
300
'''

综合练习

'''
要求：
程序启动后要求输入客户姓名
查询余额、存款、取款后都会返回主菜单
存款、取款后，都应显示一下当前余额
客户选择退出或输入错误，程序会退出，否则一直运行

定义一个全局变量：money，用来记录银行卡余额（默认5000000）
定义一个全局变量：name，用来记录客户姓名（启动程序时输入）
定义如下的函数：
查询余额函数
存款函数
取款函数
主菜单函数
'''

money = 5000000
name = input("Please input your name: ")
choice = None

def main_interface():
    global choice
    print("----------main interface----------")
    print(f"{name},Hello! Welcome to the ATM of Heima Bank. Please select the operation: ")
    print("QueryBalance--[1]")
    print("Deposit\t\t--[2]")
    print("Withdraw\t--[3]")
    print("Exit\t\t--[4]")

def QueryBalance(para):
    if para:
        print("----------QueryBalance----------")
    print(f"{name},Hello! Your remaining balance is {money} yuan")

def Deposit(mone):
    print(f"Your deposit of {mone} yuan has been successful")
    global money
    money += mone
    QueryBalance(False)

def Withdraw(mone):
    print(f"You successfully withdrew {mone} yuan")
    global money
    money -= mone
    QueryBalance(False)


while True:
    main_interface()
    choice = int(input())
    if choice == 1:
        QueryBalance(True)
    elif choice == 2:
        x = int(input("The money you want to deposit: "))
        Deposit(x)
    elif choice == 3:
        x = int(input("The money you want to withdraw: "))
        Withdraw(x)
    else:
        break

数据容器

学习数据容器，就是为了批量存储或批量使用多份数据

Python中的数据容器：

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素

每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

数据容器根据特点的不同，如：

• 是否支持重复元素

• 是否可以修改

• 是否有序，等

分为5类，分别是：列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

list(列表)

列表的定义格式

列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

my_list = ["DGUS",'gulu','python',19,True]
print(my_list)
print(f"my_list的类型是{type(my_list)}")
my_list2 = []
my_list3 = list()
my_list = [my_list3,"DGUS",'gulu','python',19,True,32.4]
print(my_list)
print(f"my_list的类型是{type(my_list)}")

'''
输出
['DGUS', 'gulu', 'python', 19, True]
my_list的类型是<class 'list'>
[[], 'DGUS', 'gulu', 'python', 19, True, 32.4]
my_list的类型是<class 'list'>
'''

列表的下标索引

1. 列表的下标索引是什么？

列表的每一个元素，都有编号称之为下标索引

从前向后的方向，编号从0开始递增

从后向前的方向，编号从-1开始递减

2. 如何通过下标索引取出对应位置的元素呢？

列表[下标]，即可取出

3. 下标索引的注意事项：

•要注意下标索引的取值范围，超出范围无法取出元素，并且会报错

如果列表是嵌套的列表，同样支持下标索引

my_list = ["DGUS",'gulu','python',19,True,[1,2,3]]
print(f"my_list中的第二个元素{my_list[1]}")
print(f"my_list中的last一个元素{my_list[-1]}")
print(f"my_list中的last一个元素的第一个元素{my_list[-1][0]}")
'''
输出
my_list中的第二个元素gulu
my_list中的last一个元素[1, 2, 3]
my_list中的last一个元素的第一个元素1
'''

列表的常用操作

掌握列表的常用操作（方法）和特点

列表也提供了一系列功能：

•插入元素

•删除元素

•清空列表

•修改元素

•统计元素个数

等等功能，这些功能我们都称之为：列表的方法

1. 列表的查询功能（方法）

• 查找指定元素在列表的下标，如果找不到，报错ValueError
  语法：列表.index(元素)
  index就是列表对象（变量）内置的方法（函数）

• 统计某元素在列表内的数量
  语法：列表.count(元素)

• 统计列表内，有多少元素
  语法：len(列表)

2. 列表的修改功能 (方法)

• 插入元素
  语法：列表.insert(下标，元素)，在指定的下标位置，插入指定的元素

• 追加元素：
  语法：列表.append(元素)，将指定元素，追加到列表的尾部

• 追加元素方式2：
  语法：列表.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部

• 删除元素：

  语法1：del 列表[下标]
  语法2：列表.pop(下标)

• 删除某元素在列表中的第一个匹配项
  语法：列表.remove(元素)

• 清空列表内容
  语法：列表.clea()

# 查询功能
my_list = ["DGUS",'gulu','python',19,True,[1,2,3],19]
index = my_list.index(19)
num = my_list.count("gulu")
len = len(my_list)
print(f"19在列表中的位置{index},gulu在列表中的个数{num},列表中元素的个数{len}")
# 修改功能
my_list = ["DGUS",'gulu','python',19,True,[1,2,3],19]
my_list.insert(1,'Happy')
print(my_list)
my_list.append("end")
print(my_list)
my_list2 = [23,42,1]
my_list.extend(my_list2)
print(my_list)
# 删除
my_list = ["DGUS",'gulu','python',19,True,[1,2,3],19]
del my_list[0]
print(my_list)
my_list.pop(1)
print(my_list)
my_list = ["DGUS",'gulu','python',19,True,[1,2,3],19]
my_list.remove('gulu')
print(my_list)
my_list.clear()
print(my_list)
'''
输出如下：
['DGUS', 'Happy', 'gulu', 'python', 19, True, [1, 2, 3], 19]
['DGUS', 'Happy', 'gulu', 'python', 19, True, [1, 2, 3], 19, 'end']
['DGUS', 'Happy', 'gulu', 'python', 19, True, [1, 2, 3], 19, 'end', 23, 42, 1]
['gulu', 'python', 19, True, [1, 2, 3], 19]
['gulu', 19, True, [1, 2, 3], 19]
['DGUS', 'python', 19, True, [1, 2, 3], 19]
[]
'''

list（列表）的遍历

使用for和while，既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。

将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代

for循环和while对比

• for循环更简单，while更灵活

• for用于从容器内依次取出元素并处理，while用以任何需要循环的场景

tuple(元组)

元组的定义格式

列表是可以修改的。如果想要传递的信息，不被篡改，列表就不合适了。

元组同列表一样，都是可以封装多个、不同类型的元素在内。
但最大的不同点在于：
元组一旦定义完成，就不可修改

元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
注意：元组只有一个数据，这个数据后面要添加逗号

元组的相关操作

1. 元组的注意事项：

• 不可修改内容（可以修改内部list的内部元素）

4. 元组的特点：

• 和list基本相同（有序、任意数量元素、允许重复元素），唯一不同在于不可修改。

• 支持循环遍历

str(字符串)

字符串同样也是数据容器的一员
字符串是字符的容器，一个字符串可以存放任意数量的字符
同前面，可以通过下标进行访问
同元组一样，字符串是一个：无法修改的数据容器
支持while循环和for循环进行遍历

• 常用操作

1. 查找特定字符串的下标索引值
   语法：字符串.index(字符串)

2. 字符串的替换

   语法：字符串.replace(字符串1，字符串2)
   功能：将字符串内的全部：字符串1，替换为字符串2
   注意：不是修改字符串本身，而是得到了一个新字符串哦

3. 符串的分割
   语法：字符串.split(分隔符字符串)
   功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
   注意：字符串本身不变，而是得到了一个列表对象

4. 字符串的规整操作

• 去前后空格
  语法：字符串.strip()
• 字符串的规整操作 (去前后指定字符串)
  语法：字符串.strip(字符串)
  注意，若传入的是“12”其实就是：＂1”和”2”都会移除，是按照单个字符。

5. 统计字符串中某字符串的出现次数
   语法：字符串.count(字符串)

6. 统计字符串的长度
   语法：len(字符串)

   

数据容器（序列）的切片

序列是指：内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以可以视为序列

序列支持切片（从一个序列中，取出一个子序列）

序列如何做切片：序列[起始:结束:步长]

• 起始可以省略，省略从头开始

• 结束可以省略，省略到尾结束

• 步长可以省略，省略步长为1（可以为负数，表示倒序执行）(后面练习有代码参考)

数据容器：set(集合)

集合，最主要的特点就是：不支持元素的重复（自带去重功能）、并且内容无序

掌握集合的常见操作

1. 加新元素
   语法：集合.add(元素)。将指定元素，添加到集合内（只添加原先不存在的）
   结果：集合本身被修改，添加了新元素

2. 移除元素

   语法：集合.remove(元素)，将指定元素，从集合内移除
   结果：集合本身被修改，移除了元素

3. 从集合中随机取出元素
   语法：集合.po()，功能，从集合中随机取出一个元素
   结果：会得到一个元素的结果。同时集合本身被修改，元素被移除

4. 清空集合
   语法：集合.clear()，功能，清空集合
   结果：集合本身被清空

5. 取出2个集合的差集
   语法：集合1.difference(集合2)，功能：取出集合1和集合2的差集(集合1有而集合2没有的）
   结果：得到一个新集合，集合1和集合2不变

6. 消除2个集合的差集

   语法：集合1.difference_update(集合2)

   结果：对比集合1和集合2，在集合1内，删除和集合2相同的元素。集合1被修改，集合2不变

7. 2个集合合并

   语法：集合1.union(集合2)

   结果：将集合1和集合2组合成新集合，得到新集合，集合1和集合2不变

8. 查看集合的元素数量

   语法：len(集合)

集合的常用操作 - for 循环遍历（某些特殊情况可以用while循环 使用pop方法）

数据容器：dict（字典）

1. 定义

为什么使用字典？ 因为可以使用字典，实现用 key 取出 Value 的操作

字典的定义，同样使用{ }，不过存储的元素是一个个的：键值对，如下语法：

使用{ }存储原始，每一个元素是一个键值对
每一个键值对包含Key和Value（用冒号分隔）
键值对之间使用逗号分隔
Key和Value可以是任意类型的数据(key不可为字典)
Key不可重复，重复会对原有数据覆盖

字典同集合一样，不可以使用下标索引 但是字典可以通过Key值来取得对应的Value

my_dict = {
    "gulu":{"math":99,"english":90,"chinese":80},
    "zlin":{"math":92,"english":95,"chinese":97},
    "cshi":{"math":94,"english":85,"chinese":89}
}
gulu_math = my_dict["gulu"]["math"]
print(gulu_math)

2. 常用操作

• 新增or更新元素
  语法：字典[Key]=Value，新增还是更新取决于这个元素原先是否存在

• 删除元素
  语法：字典.pop(Key)，结果：获得指定Key的Value（可以用变量接受），同时字典被修改，指定Key的数据被删除

• 清空字典
  语法：字典.clearO，结果：字典被修改，元素被清空

• 获取全部的key
  语法：字典.key()，结果：得到字典中的全部Key

• 遍历字典

  语法：for key in字典.keys()–(一般情况使用for循环遍历即可)

• 计算字典内的全部元素（键值对）数量

  语法：len(字典)

对比总结

数据容器可以从以下视角进行简单的分类：

• 是否支持下标索引

•支持：列表、元组、字符串 - 序列类型

•不支持：集合、字典 - 非序列类型

• 是否支持重复元素：

•支持：列表、元组、字符串 - 序列类型

•不支持：集合、字典 - 非序列类型

• 是否可以修改

•支持：列表、集合、字典

不支持：元组、字符串

数据容器的通用操作

len(容器)

统计容器的元素个数

max(容器)

统计容器的最大元素

min(容器)

统计容器的最小元素—（使用到字符串比较大小ASCII）

• 通用排序功能
  sorted(容器, [reverse=True]) 将给定容器进行反向排序 注意，排序后都会得到列表（list）对象
  sorted(容器)：正向排序
  ​

练习

list常见功能

'''
有一个列表，内容是：[21，25，21，23，22，20]，记录的是一批学生的年龄
请通过列表的功能（方法），对其进行
1．定义这个列表，并用变量接收它
2.追加一个数字31，到列表的尾部
3．追加一个新列表[29，33，30]，到列表的尾部
4.取出第一个元素 (应是：21)
5．取出最后一个元素 (应是：30)
6．查找元素31，在列表中的下标位置
'''

my_list = [21,25,21,23,22,20]
my_list.append(31)
print(my_list)
my_list.append([29,33,30])
print(my_list)
first_element = my_list[0]
last_element = my_list[-1][2]
print(f"first_element{first_element},last_element{last_element}")
index = my_list.index(31)
print(f"element31在列表中的位置{index}")

使用循环遍历list

'''
定义—个列表，内容是：[1,2,3,4,5,6,7,8,9,10]
遍历列表，取出列表内的偶数，并存入一个新的列表对象中
使用while循环和for循环各操作一次
'''

l1 = []
my_list = [1,2,3,4,5,6,7,8,9,10]
for x in my_list:
    if x % 2 ==0:
        l1.append(x)
print(l1)
l2 = list()
index = 0
while index < len(my_list):
    if my_list[index] % 2 ==0:
        l2.append(my_list[index])
    index += 1
print(l2)

tuple基本使用

'''
定义一个元组，内容是：（周杰轮，11，[football'，'music']），
记录的是一个学生的信息（姓名、年龄、爱好)
请通过元组的功能（方法），对其进行
1．查询其年龄所在的下标位置
2．查询学生的姓名
3．删除学生爱好中的football
4.增加爱好：coding到爱好list内
'''
t1 = ('周杰轮',11,['football','music'])
age = t1.index(11)
del t1[2][0]
print(f"年龄所在下表位置{age},{t1}")
t1[2].append('coding')
print(t1)

序列的切片实践

'''
有字符串："万过薪月，员序程马黑来，nohtyP学"
请使用学过的任何方式，得到"黑马程序员”
'''

my_str = "万过薪月,员序程马黑来,nohtyP学"
# convenience
new_str = my_str[::-1][9:14]
print(new_str)
# convenience2
new_str = my_str.split(',')[1][-2::-1]
print(new_str)

集合set练习

'''
有如下列表对象：
my_list=['黑马程序员'，'传智播客'，'黑马程序员'，'传智播客'，
         "itheima'，"itcast'，itheima'，'itcast"，'best']
请：
定义一个空集合
通过for循环遍历列表
在for循环中将列表的元素添加至集合
最终得到元素去重后的集合对象，并打印输出
'''

my_list=['黑马程序员','传智播客','黑马程序员','传智播客',
         'itheima','itcast','itheima','itcast','best']
set1 = set()
for i in my_list:
    set1.add(i)
print(set1)

dict练习

'''
有如下员工信息，请使用字典完成数据的记录。
并通过for循环，对所有级别为1级的员工，级别上升1级，薪水增加1000元
'''

my_dict = {
    "wlh":{"department":"technology","salary":3000,"level":1},
    "zjl":{"department":"market","salary":5000,"level":2},
    "ljj":{"department":"market","salary":7000,"level":3},
    "zxy":{"department":"technology","salary":4000,"level":1}
}
print("current information")
print(my_dict)
print("after elevating")
for key in my_dict:
    if my_dict[key]["level"] == 1:
        my_dict[key]["level"] += 1
        my_dict[key]["salary"] += 1000
print(my_dict)

幸运数字6

'''
幸运数字6：输入任意数字，如数字8，生成nums列
表，元素值为1～8，从中选取幸运数字（能够被6整除
)移动到新列表lucky，打印nums与lucky。
'''

num = int(input("Please input any interger: "))
nums = []
lucky = []
for i in range(1,num+1):
    nums.append(i)
for i in nums:
    if i % 6 == 0:
        lucky.append(i)
print(nums)
print(lucky)