前言
1.声明：本次是作者学习Python的记录文档，只挑选了重点，可能会有一些缺陷甚至错误。
2.学习目的：从零搭建Python认知，掌握基础语法、建立代码思维
一、初始函数
python
name = "lanzhishujiaxueyuan"
# 需求：统计字符串的长度
length = len(name)
print(f"字符串name的长度是：{length}")
"""
len()是python内置的函数
# 提前写好的
# 可以重复使用
# 实现统计长度这以特定功能的代码段
"""
# 需求：不使用内置函数len()，完成字符串长度的计算
name2 = "haihai! zhe li shi ya bian kan wu !"
# 定义一个计数变量
count = 0
# 使用for循环变量
for i in name2:
count += 1 # count = count + 1 count = 0 + 1
print(f"字符串{name2}的长度是：{count}")
name3 ="haihia! wawawawa!"
# 定义一个计数变量
count = 0
# 使用for循环变量
for i in name3:
count += 1 # count = count + 1 count = 0 + 1
print(f"字符串{name3}的长度是：{name3}")
# 每统计一个字符串的长度都需要写一个for循环，非常麻烦，代码 冗余
str1 = "ddddddkkkkdasd asdasdasd"
str2 = "ddddddddggggkkkkdasd asdasdasd"
str3 = "dddddfffdkkkkdasd asdasdasd"
# 可以使用函数，来优化这些功能
def my_len(data):
count = 0
for i in data:
count += 1
print(f"字符串{data}的长度是：{count}")
# 使用函数
my_len(str1)
my_len(str2)
my_len(str3)二、函数的定义
函数定义语法格式：
def 函数名(传入的参数): # 参数暂不讨论
函数体
return 返回值 # 返回值暂不讨论
函数使用语法格式：
函数名(参数)
def 函数名():
函数体
python
def yabian():
print("崖边看雾！")
yabian()例子
python
"""定义一个函数，函数名随意，要求调用函数后可以输出一下欢迎语：
早上好！
请刷脸开门！
"""
# 定义一个函数
def face_scan():
# 输出
print("早上好！\n请刷脸开门！")
# 使用函数
face_scan()
三、函数参数
掌握函数传入参数的使用
函数传入参数功能：在函数进行计算的时候，接收外部（调用时）提供的数据。
函数定义语法格式：
def 函数名(传入的参数):
函数体
函数传入的参数：函数传入参数的数量是不受限制的。
（1）可以不使用参数
（2）也可以使用N个参数
python
# 需求：要求使用函数完成两个数据相加的功能
def add(x,y):
result = x + y
print(f"{x} + {y} 的结果是：{result}")
# 使用
add(4,4)函数解析：
1、函数定义中，提供的x和y，称之为：形式参数（形参），表示函数声明将要使用2个参数，参数之间使用逗号分隔。
2、函数使用中，提供的4和4，称之为：实际参数（实参），表示函数执行的时候真正使用的参数值，传入的时候，按照顺序传入数据，使用逗号分隔。练习
练习：升级自动刷脸
定义一个函数，函数名随意，并接受一个参数传入（数字类型，是否是本人）
在函数体内进行本人判断（1本人，0非本人），并输出如下内容：
早上好！请刷脸开门！
人脸识别中，您的状态码为：1，本人，请进。
早上好！请刷脸开门！
人脸识别中，您的状态码为：0，非本人，请离开
python
def face_scan(is_me):
print("早上好！请刷脸开门！")
if is_me == 1:
print("人脸识别中，您的状态码为：1，本人，请进。")
else:
print("人脸识别中，您的状态码为：0，本人，非本人，请离开。")
# 调用函数
face_scan(0)四、函数返回值
1、函数返回值的定义
学习目标：
(1)掌握函数返回值的作用
(2)掌握函数返回值的定义语法
函数返回值：就是程序中函数完成事情后，最后给调用者的结果。
函数返回值语法格式：
def 函数名(参数......):
函数体
return 返回值
函数使用语法格式：
变量名 = 函数名(参数.....)
2、None类型
思考？如果函数没有使用return语句返回数据，那么函数有返回值吗？ 有的
python中有一个特殊字面量：None，其类型是：<class 'NoneType'>
无返回值的函数，实际上就是返回了None字面量
None：表示空的，无实际意义的，
函数返回None，就表示这个函数没有返回什么有意义的内容，也就是返回空的意思。
None类型的使用场景： 1、用在函数无返回值
2、用在if判断上
（1）在if判断中None相当于False
（2）一般用在函数中主动返回None，配合if判断做相关处理
3、用于声明无内容的变量上
（1）定义变量，但暂时不需要变量有具体的值，可以用None类型
python
def add(a,b):
result = a + b
return result
r = add(1,2)
print(r)
python
def add2(a,b):
result = a + b
r2 = add2(1,2)
print(r2)
python
# 主动返回None
def say_hi():
print("hello func!")
return None
result = say_hi()
print(f"主动返回None函数的内容是：{result},其类型是：{type(result)}")
python
# None 用在if判断上
def check_age(age):
if age > 18:
return "成年！"
else:
return None
result2 = check_age(17)
if not result2:
print("年龄小于18")
python
# 用在声明变量上
name = None
age = None五、函数说明文档
1、掌握通过注释对函数进行解释说明
函数是纯代码语言，想要理解其含义就需要一行行去阅读理解代码，效率比较低
可以给函数添加说明文档，辅助理解函数的作用。
"""
# 函数说明文档语法格式：
# def func(x,y):
# """
# 函数说明
# :param x: 形参x的说明
# :param y: 形参y的说明
# :return: 返回值
# """
# 函数体
# return 返回值
python
# 定义一个函数，进行文档说明
def add(a,b):
"""
add函数可以接收2个参数，进行两数相加的功能。
:param a: 形参a表示相加的一个数字
:param b: 形参a表示相加的另一个数字
:return: 返回值是两数相加的结果
"""
result = a + b
print(f"a+b的结果是：{result}")
return result
# 使用函数,在pycharm中编写代码时，可以通过鼠标悬停，查看调用函数的说明文档。
add(1,2)六、函数的嵌套使用
学习目标：
1、掌握函数的嵌套使用
2、理解嵌套调用的执行流程
函数嵌套调用：指的是一个函数里面又调用了另外一个函数，
执行流程：如果函数A中，调用另外一个函数B,那么先把函数B中的任务都执行完毕之后才会回到上次函数A执行的地方继续执行
python
# 定义函数B
def func_B():
print("***1***") ##第二个输出
# 定义函数A
def func_A(): #第一步执行
print("***2***") ##第一个输出
# 使用函数B
func_B() ##回到函数B的定义
print("***3***") ##第三个输出
# 调用函数A
func_A()七、变量的作用域
变量的作用域（作用范围）：变量作用域指的是变量的作用范围（变量在哪里可用，哪里不可用）
变量的作用域分类：
局部变量：在函数体内部的变量，即只在函数体内生效
局部变量作用：在函数体内部，临时保存数据，即当函数调用完后，则销毁局部变量
全局变量：指的是在函数体内、外都能生效的变量
global 关键字：可以在函数体内部声明变量为全局变量
python
# 在函数内修改全局变量
# 定义一个全局变量
a = 100
# 定义一个函数B
def func_B():
print(a)
def func_C():
global a ##此处声明a为全局变量
a = 200
print(a)
func_B()
func_C()
print(a)八、综合案例
"""
综合案例：ATM
定义一个全局变量：money，用来记录银行卡余额（默认余额为：60000000）
定义一个全局变量：name，用来记录客户姓名（程序启动时输入）
定义如下函数：
查询余额函数
存款函数
取款函数
主菜单函数
要求：
程序启动后要求输入客户姓名
查询余额、存款、取款后都会返回主菜单
存款、取款后，都应显示一下当前余额
客户选择退出或者输入错误，程序会退出，否则会一直运行
主菜单效果：
---------------------主菜单-----------------------------
xxxx，您好，欢迎来到数加银行ATM。请选择操作：
查询余额 【请输入1】
存款 【请输入2】
取款 【请输入3】
退出 【请输入4】
请输入您的选择：
查询余额的效果：
---------------------查询余额-----------------------------
xxxx，您好，您的余额剩余：60000000元
存、取款效果:
---------------------存款-----------------------------
xxxx,您好，你存款50000元成功！
xxxx，您好，您的余额剩余：60050000元.
---------------------取款-----------------------------
xxxx,您好，你取款50000元成功！
xxxx，您好，您的余额剩余：60000000元.
"""
python
# 定义全局变量
money = 60000000
name = None
# 要求输入姓名
name = input("请输入您的姓名：")
# 定义查询余额函数
def query(is_show): ##布尔值参数
if is_show: ##为真，则运行下一行的标题
print("---------------------查询余额-----------------------------")
print(f"{name}，您好，您的余额剩余：{money}")
# 定义存款函数
def saving(num):
global money
money += num
print("---------------------存款-----------------------------")
print(f"{name}, 您好，你存款{num}元成功！")
# 调用查询函数
query(False)
# 定义取款函数
def get_money(num):
global money
money -= num
print("---------------------取款 - ----------------------------")
print(f"{name}, 您好，你取款{num}元成功！")
query(False)
# 定义主菜单函数
def main():
print("---------------------主菜单-----------------------------")
print(f"{name}，您好，欢迎来到数加银行ATM。请选择操作：")
print("查询余额 【请输入1】")
print("存款 【请输入2】")
print("取款 【请输入3】")
print("退出 【请输入4】")
return input("请输入您的选择：")
# 程序一直执行 无限循环
while True:
# 调用主菜单函数
key_word = main()
# print(key_word)
# 判断用户的选择
if key_word == "1":
query(True)
# 结束本次循环
continue
elif key_word == "2":
# 输入存的钱
num = int(input("请输入您要存多少钱："))
saving(num)
# 结束本次循环
continue
elif key_word == "3":
# 取多少钱
num = int(input("请输入您取款多少钱?"))
get_money(num)
# 结束本次循环
continue
else:
print(f"程序退出")
break九、列表
数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素，每一个元素，可以是任意类型的数据，如：字符串、数字、布尔等。
数据容器的分类：
列表（List）、元组（Tuple）、字符串（Str）、集合（Set）、字典（dict）
列表（List）：
1、列表的定义
2、列表的下标索引
3、列表的常用操作
学习目标：
(1)掌握列表的定义格式
(2)掌握使用列表的下表索引从列表中取出元素
(3)掌握列表的常用操作（方法）和特点
列表定义语法格式：
1、字面量
元素1,元素2,元素3,元素4,元素5,元素6,.....
2、定义列表变量
变量名称 = 元素1,元素2,元素3,元素4,元素5,元素6,.....
3、定义空列表
变量名 = \[\]
变量名 = list()
列表：列表内的每一个数据，称之为元素，以\[\]作为标识，列表内的每一个元素之间使用逗号隔开。
列表的下标（索引）：
列表的每一个元素，都有编号，称之为下标索引。
列表的正向索引：从前向后方向，编号从0开始。
语法格式：
列表下标索引
列表的反向索引：从后向前方向，编号从-1开始。
语法格式：
列表下标索引
嵌套列表的下标索引语法格式：
列表外层标号内层标号
列表的常用操作：
如：插入元素、删除元素、清空列表、修改列表、统计元素个数等常用功能。
1、列表的查询功能
查询某元素的下标
语法：列表.index(元素)：查找指定元素在列表中的下标，如果找不到，则报错：ValueError
2、修改特定位置（索引）的元素值
语法：列表下标 = 值 ：直接对指定下标（正向、反向下标）的值进行重新赋值（修改）
3、插入元素
语法：列表.insert(下标,值):在指定的下标位置，插入新的元素
4、追加元素
语法：列表.append(元素):将指定元素追加到列表的末尾。
5、追加元素2
语法：列表.extend(其他数据容器)：将其他数据容器内容取出，依次追加到列表的末尾
6、删除元素1
语法1：del 列表下标
7、删除元素2
语法2：列表.pop(下标)
8、删除某元素在列表中的第一个匹配项
语法：列表.remove(元素)
9、清空列表内容
语法：列表.clear()
10、统计列表中元素的个数
语法：len(列表)
总结：
列表的特点
1、可以容纳多个元素
2、可以容纳不同数据类型的数据（混装）
3、数据是有序存储的（下标索引）
4、允许重复数据存在
5、可以修改（增加删除....）
python
# 列表字面量
["hai!","hiahia!","崖边看雾"]
print(["hai!","hiahia!","崖边看雾"])
#列表自变量
my_list = ["hai!","hiahia!","崖边看雾"]
print(my_list)
print(type(my_list))
#空列表
my_list1 = []
print(my_list1)
print(type(my_list1))
my_list2 = list()
print(my_list2)
print(type(my_list2))
my_list3 = ["hai!","hiahia!","崖边看雾",8888,True,'66']
print(my_list3)
# 定义一个嵌套列表
my_list4 = [[1,2,3,4],["a","b","c"]]
print(my_list4)
python
#*********************列表的下标索引****************
my_list5 = ["python","linux","mysql","hadoop"]
# 需求：正向取mysql这个元素
print(my_list5[2]) ##从0开始
# 需求：反向取mysql这个元素
print(my_list5[-2]) ##从-1开始
#**************嵌套列表下标索引***************
my_list6 = [[1,2,3,4],["a","b","c"]]
print(my_list6[0][2]) ##第一个代表第几组，后面代表如何索引
print(my_list6[1][1])
print(my_list6[0][-1])
print(my_list6[1][-2])
python
#***********列表的常用操作*************
#index()从左往右查找目标元素，只返回第一个匹配元素的下标（索引）
my_list7 = ["python","linux","python","mysql","python","hadoop","hdfs","mapreduce","linux","python","linux","linux","yarn","hive"]
result1 = my_list7.index("python")
print(result1)
# result2 = my_list7.index("python1111") # 报错
# print(result2)
# 列表[下标] = 值
print(f"修改前列表的结果是：{my_list7}")
my_list7[2] = "pandas"
print(f"修改后列表的结果是：{my_list7}")
# 列表.insert(下标,值)
my_list7.insert(5,"spark")
print(f"插入新值后的列表结果是：{my_list7}")
# 列表.append(元素)
my_list7.append("flink")
print(f"追加新元素后的结果是：{my_list7}")
# 列表.extend(其他数据容器)
my_list7.extend([1,2,3,4,5])
print(f"追加新元素后的结果是：{my_list7}")
# del 列表[下标]
del my_list7[5]
print(f"删除元素后的列表结果是：{my_list7}")
# 列表.pop(下标)，按下标删除，能拿到被删掉的元素
result = my_list7.pop(0)
print(result)
print(f"删除元素后的列表结果是：{my_list7}")
print(my_list7)
# 列表.remove(元素)，按元素内容删除，只删第一个匹配项
my_list7.remove("linux")
print(f"删除元素后的列表结果是：{my_list7}")
# 列表.clear()
my_list7.clear()
print(f"清空之后的列表结果是：{my_list7}")
my_list8 = ["python","linux","python","mysql","python","hadoop","hdfs","yarn","hive"]
# len(列表)
print(len(my_list8))十、作业
python
#编写一个函数 sum_list，返回一个列表中所有元素的和。[1, 2, 3, 4]
lizi_list = [1, 2, 3, 4]
def sum_list(lizi_list):
sum = 0
for i in lizi_list:
sum += i
return sum
he = sum_list(lizi_list)
print(he)
python
#编写一个函数 find_max，返回列表中的最大值。[1, 5, 3, 9, 2]
list1 = [1, 5, 3, 9, 2]
def find_max(list1):
my_max = list1[0]
for i in list1:
if i>my_max:
my_max = i
return my_max
m = find_max(list1)
print(m)
python
#编写一个函数 factorial，使用 while 循环计算一个数的阶乘。 5
def factorial(n):
chushi = 1
while n>1:
chushi *= n
n -= 1
return chushi
print(factorial(5))
python
#使用 for 循环遍历一个列表并将每个元素乘以2。[1, 2, 3, 4, 5]
list2 = [1, 2, 3, 4, 5]
list_new = []
for i in list2:
list_new.append(i*2)
print(list_new)
python
#编写一个函数 fibonacci，返回前n个斐波那契数。 10
def feibo(n):
if n == 1:
return [1]
arr = [1,1] ##斐波那契数列初始为1,1
for i in range(2, n):
arr.append(arr[-1] + arr[-2])
return arr
print(feibo(10))
python
#编写一个函数 remove_duplicates，去除列表中的重复元素。[1, 2, 2, 3, 4, 4, 5]
def remove_duplicates(old_list):
new_list = [] # 用来存放去重后的新列表
for i in old_list:
# 新列表里还没有这个元素，才追加
if i not in new_list:
new_list.append(i)
return new_list
# 测试调用
t_list = [1, 2, 2, 3, 4, 4, 5]
res = remove_duplicates(t_list)
print(res)
python
#编写一个函数 flatten_list，将嵌套列表展开成一个单层列表。 [1, [2, 3], [4, [5, 6]], 7]
def flatten_list(let):
flat_list = []
for item in let:
if isinstance(item, list):
flat_list.extend(flatten_list(item))
else:
# 如果不是列表
flat_list.append(item)
return flat_list
print(flatten_list([1, [2, 3], [4, [5, 6]], 7]))
python
#编写一个函数 remove_duplicates_preserve_order，从列表中删除重复项并保持原来的顺序。[1, 2, 2, 3, 4, 4, 5]
def remove_duplicates_preserve_order(xiti8):
seen = set () ##定义一个集合
new_list = [] ##定义一个空列表
for i in xiti8:
if i not in seen:
new_list.append(i)
seen.add(i)
return new_list
print(remove_duplicates_preserve_order([1, 2, 2, 3, 4, 4, 5]))
python
#编写一个函数 find_pairs_with_sum，在一个列表中找到所有和为指定值的数对。[1, 2, 3, 4, 5, 6]；target = 7
def find_pairs_with_sum(lst,target):
# 初始化一个空列表用于存储和为 指定值（target） 的数对
paris = []
# 初始化一个空集合用于存储已经遍历过的数字
seen = set()
# 遍历列表中的每一个数字
for number in lst:
# 计算补数 使得 number + a = target
a = target - number
# 如果补数在集合seen中，说明找到了一个和为 target 的数对
if a in seen:
# 将这个数对添加到 paris 中
paris.append((a,number))
# 将当前的数字添加到集合中，以便后续查找
seen.add(number)
# 返回所有数对
return paris
print(find_pairs_with_sum([1, 2, 3, 4, 5, 6],7))
python
#编写一个函数 longest_consecutive_sequence，找到一个列表中的最长连续子序列。[100, 4, 200, 1, 3, 2]
def longest_consecutive_sequence(lst):
# 判断这个列表是否为空
if not lst:
return 0
# 将列表转换为集合并排序，去除重复数据
lst = sorted(set((lst)))
print(lst) # [1, 2, 3, 4, 100, 200]
# 初始化最长序列长度 和 当前连续序列长度
longest = 1
current_streak = 1
# 从第二个元素开始遍历
for i in range(1,len(lst)):
# 如果当前元素等于前一个元素 + 1 ，标识当前元素是连续的
if lst[i] == lst[i - 1] + 1:
current_streak += 1
else:
# 如果不连续，更新最长序列长度，并充值当前连续序列长度
longest = max(longest,current_streak)
current_streak = 1 #
# 最后返回最长连续序列长度，确保包括最后的连续序列
return max(longest,current_streak)
print(longest_consecutive_sequence([100, 4, 200, 1, 3, 2]))