「Python」基础语法学习全过程笔记（含代码示例及运行结果）

测试划水老师傅2023-09-24 16:38

文章目录

前言：这一篇文章，包含了 Python 所有的基础语法知识。

原本自己一直在自学Java，因为工作需要，从一个Java的菜鸟转到Python的学习。

个人认为：

不论从效率还是功能上，Python更适合软件测试人员的使用。

期间，零零碎碎的做一些笔记，包含了基础语法以及其他奇淫技巧工具等。

自己关于测试所有的笔记，慢慢整理在CSDN上，利人利己。

我建议初学者：

  1. 不要只看别人的文章，还要自己动手写写。
  2. 甭管在你看来多简单的代码，边写边思考，多换换思路和写法去尝试举一反三。
  3. 学习过程中，可以多"作"下，别怕报错，报错才是进步的开始！

一、Python命名规范

  1. 模块命名：模块尽量使用小写命名，首字母保持小写，尽量不要用下划线
python 复制代码 
from unittest import util
  1. 类名：类名使用驼峰命名风格，首字母大写，私有类可用一个下划线开头。
python 复制代码 
class Student:
	pass
python 复制代码 
class _PrivateStudent:
	pass
  1. 函数：函数名一律小写，如有多个单词，用下划线隔开。私有函数在函数前加一个下划线_。
python 复制代码 
def pay():
	pass
def wechat_pay():
	pass
def _private_pay():
	pass
  1. 变量名：变量名尽量小写，如有多个单词，用下划线隔开。
python 复制代码 
name = "Kevin"
nick_name = "测试划水老师傅"
  1. 常量：常量使用以下划线分隔的大写命名。
python 复制代码 
ROOT_PATH = "https://www.baidu.com/"

二、Python变量

变量的作用

程序中，数据都是临时存储在内存中，为了更快速的查找或使用存储的数据，通常我们把这个数据在内存中存储后，定义一个名称表示该数据，这个名称就是变量。
也就是说，变量就是一个存储数据的时候，当前数据所在内存地址的名字。

定义变量

python 复制代码 
# 变量名 = 值
name = "测试划水老师傅"

变量引用

Python中，值是靠引用来传递，可以用方法id()来判断两个变量是否是同一个值得引用。可以将id的值理解为存储内存的地址标识。

注：print() 函数在Python中，表示"输出"的意思，后面的章节会详细介绍。

python 复制代码 
a = 10
b = a
print(f'a的值{a}')
print(f'a的内存地址{id(a)}')
print(f'b的内存地址{id(b)}')
"""run:
a的值10
a的内存地址1576429158928
b的内存地址1576429158928
"""

交换变量的值

python 复制代码 
a = 10
b = 20
"""
方法-1：借助第三变量存储数据
1.1 定义中间的第三变量，为了临时存储a或b的数据
1.2 把a的数据存储到c, 进行保存。
1.3 把a的数据赋值到a, a = 20
1.4 把c的数据赋值到b, b = 10
"""
c = 0
c = a
a = b
b = c
print(a)
print(b)

"""
方法-2：更简单优化，推荐使用这种。
"""
a, b = 10, 20
a, b = b, a
print(a)
print(b)

"""run:
20
10
20
10
"""

三、Python数据类型

我们其实已经知道编程中，数据类型有什么"int、string"等。

但在我自学这一篇内容时，我问自己：
"数据类型"是什么？
为什么编程中，要定义"数据类型"？

所以，你有没有想过类似这些问题？

我的结论：

  1. 无疑，这是创建这门语言作者，制定的一种规范。（尽管他参考的是已有语言，所以我们常说，编程语言是相同的）
  2. 规定了数据的存储范围。
  3. 规定了数据的操作方式。
  4. 这样的规范，提高了程序运行的可靠性 、效率。

当然，现在这些我没有办法去举一些例子告诉你，也许在你慢慢学习过程中，会逐步体验到"规范"的意义！

Python中的数据类型：

python 复制代码 
数值：
	- int（整型）	number = 1
	- float（浮点型） number = 1.1
布尔型：
	- True（真） is_man = True
	- False（假）is_man = False
字符串str：
	- my_name = "测试划水老师傅"
列表list：
	- num_list = [1,2,3]
元组tuple：
	- num_tuple = (10,20,30)
集合set:
	- num_set = {1,2,3}
字典dict:
	- my_info = {"name": "测试划水老师傅", "age": 30}

字符串

python 复制代码 
str_abc = 'abc'
str_ABC = "ABC"
str_123 = '''123'''
str_other = """@#$%^&"""
print(f"str_abc：数据{str_abc},数据类型{type(str_abc)}")
print(f"str_ABC：数据{str_ABC},数据类型{type(str_ABC)}")
print(f"str_123：数据{str_123},数据类型{type(str_123)}")
print(f"str_other：数据{str_other},数据类型{type(str_other)}")

根据下标获取字符串中某个字符

python 复制代码 
str_abc = 'abc'
print(f"str_abc：获取{str_abc}字符串的第1个字符是：{str_abc[0]}")

字符串的运算

python 复制代码 
print("抖音" + "测试划水老师傅！")
print("测试划水老师傅！" * 3)

查找 find

find() 检查某个子串是否包含在这个字符串，如果包含返回该下标，否则返回-1。

python 复制代码 
"""
语法：
字符串序列.find(子串,开始位置下标,结束位置下标)#不输入下标默认整个字符串
"""
str = "My name is Python."
print(str.find("name"))

查找 index

index() 检查某个子串是否包含在这个字符串，如果包含返回该下标，否则程序报错。

python 复制代码 
"""
语法：
字符串序列.index(旧子串,新子串,替换次数)
"""
str = "My name is Python."
print(str.index("name"))

统计 count()

count() 统计某个子串在该字符串中出现几次。

python 复制代码 
"""
语法：
字符串序列.count(子串)
"""
str = "My name is Python."
print(str.count("n"))

判断 isalnum、isalpha、isdigit...

python 复制代码 
str_abc = 'abc'

# isalnum() 检测字符串是否仅包含0-9 A-Z a-z
print(f"str_abc：数据{str_abc},是否仅包含0-9 A-Z a-z？{str_abc.isalnum()}")

# isalpha() 检测字符串是否仅包含A-Z a-z
print(f"str_abc：数据{str_abc},是否仅包含A-Z a-z？{str_abc.isalpha()}")

# isdigit() 检测字符串是否仅包含数字
print(f"str_abc：数据{str_abc},是否仅包含数字？{str_abc.isdigit()}")

# islower() 检测字符串是否均为小写
print(f"str_abc：数据{str_abc},是否均为小写？{str_abc.islower()}")

# isspace() 检测字符串是否出现空白字符
print(f"str_abc：数据{str_abc},是否出现空白字符？{str_abc.isspace()}")

# istitle() 检测字符串是否首字母大写
print(f"str_abc：数据{str_abc},是否首字母大写？{str_abc.istitle()}")

# isupper() 检测字符串是否均为大写
print(f"str_abc：数据{str_abc},是否均为大写？{str_abc.isupper()}")

修改 replace

python 复制代码 
"""
语法：
字符串序列.replace(旧子串，新子串，替换次数)
说明replace并为对原有数据进行修改，修改后的数据是replace函数的返回值
字符串数据类型是不可变数据类型
"""

str = "Java Java is cool."
new_str = str.replace("Java","Python",1)
print(str)
print(new_str)

"""
Java Java is cool.
Python Java is cool.
"""

分割 split

split():按照指定字符分割字符串

python 复制代码 
"""
语法：
字符串序列.split(分割字符，num)，num表示的是分割字符出现的次数，即将来返回数据的个数为num+1个
"""

str = "Java, Java, is cool."
str_list = str.split(",",1) #不添加第二个参数，会将所有"，"作为分割符合进行分割
print(str)
print(str_list)
print(type(str_list))

"""
Java, Java, is cool.
['Java', ' Java, is cool.']
<class 'list'>
"""

切片 通过下标

python 复制代码 
"""
语法：
序列[开始位置下标：结束位置下标：步长]
不包含结束位置下标位置数据
"""
str_1 = "My name is Python"
print(str_1[11:-1:1])

合并 join

join():合并列表里面的字符串为一个新的字符串

python 复制代码 
"""
语法：
字符或子串.join(多字符串组成的序列)
"""
my_list = ['aa','bb','cc']
new_str = '...'.join(my_list)
print(new_str)

"""
aa...bb...cc
"""

转换大小写 capitalize、lower、swapcase、title、upper

python 复制代码 
# 注意：split() join() 函数仅返回制定字符串的分割后的列表，不改变原字符串内容。
str_abc = 'abc'
str_ABC = "ABC"

# capitalize() 首字母大写
print(f"str_abc：数据{str_abc},首字母大写{str_abc.capitalize()}")

# lower() 将字符串全部转换为小写
print(f"数据{str_ABC},结果是：{str_ABC.lower()}")

# swapcase() 将字符串中大写转换为小写，小写转换为大写
print(f"数据{str_ABC},结果是：{str_ABC.swapcase()}")

# title() 将单词首字母大写
print(f"数据{str_abc},结果是：{str_abc.title()}")

# upper() 将字符串全部转换为大写
print(f"数据{str_abc},结果是：{str_abc.upper()}")

列表

python 复制代码 
l = [数据1,数据2,数据3.....]
  1. 列表可以一次性存储多个数据，且可以为不同数据类型，一般建议存储类型一致。
  2. 列表为可变数据，即修改后，原有数据会被修改。

根据下标查找列表元素

python 复制代码 
name_list = ["Kevin","Tom","Jack"]
print(name_list[0])
print(name_list[1])
print(name_list[2])

"""
Kevin
Tom
Jack
"""

查找 index()

返回制定数据所在位置的下标

python 复制代码 
"""
语法：列表序列.index(数据,开始位置下标,结束位置下标)
"""
name_list = ["Kevin","Tom","Jack"]
print(name_list.index('Tom',0,2))
print(name_list.index('Kevin'))
print(name_list.index('Kevin_1111'))

"""
1
0
Traceback (most recent call last):
  File "E:/giteespace/python/基础知识/列表.py", line 13, in <module>
    print(name_list.index('Kevin_1111'))
ValueError: 'Kevin_1111' is not in list
"""

统计 count()

返回统计制定数据在当前列表中出现的次数

python 复制代码 
name_list = ["Kevin","Tom","Jack"]
print(name_list.count("Kevin"))
print(name_list.count("kevin"))
print(name_list.count("Bob"))

"""
1
0
0
"""

长度 len()

访问列表长度，即列表中数据的个数

python 复制代码 
name_list = ["Kevin","Tom","Jack"]
print(len(name_list))

"""
3
"""

判断是否存在 in

判断制定数据在某个列表序列，如果在返回True，否则返回False

python 复制代码 
name_list = ["Kevin","Tom","Jack"]
#结果True
print('Kevin' in name_list)
#结果False
print('Kevin_ss' in name_list)

"""
True
False
"""
python 复制代码 
name_list = ["Kevin","Tom","Jack"]
name = input("请输入你要搜索的名字：")
if name in name_list:
    print(f"您输入的用户名{name}，已经存在！")
else:
    print(f"您输入的用户名{name},不存在")
    
"""
请输入你要搜索的名字：Kevin
您输入的用户名Kevin，已经存在！
"""

判断是否存在 not in

判断制定数据不在某个列表序列，如果不在返回True，否则返回False

python 复制代码 
name_list = ["Kevin","Tom","Jack"]
#结果False
print('Kevin' not in name_list)
#结果True
print('Kevin_ss' not in name_list)

"""
False
True
"""

删除 del()

可删除列表对象，也可以删除列表中某一个下标元素

python 复制代码 
"""
1.del 列表对象  \ del 列表[下标]
"""
name_list = ["测试划水老师傅","Python","Java"]
del name_list
print(name_list)
"""run:
Traceback (most recent call last):
  File "E:/****/****/****/列表.py", line 15, in <module>
    print(name_list)
NameError: name 'name_list' is not defined #对象已被删除，所以打印语句报错
"""
name_list = ["测试划水老师傅","Python","Java"]
del name_list[0]
print(name_list)

"""run:
['Python', 'Java']
"""

删除 pop()

不输入列表下标，默认删除列表最后一个元素，并返回被删除列表元素内容

python 复制代码 
"""
2.列表.pop(下标),返回被删除对象
"""
name_list = ["测试划水老师傅","Python","Java"]
pop_name_one = name_list.pop()
print(name_list)
print(pop_name_one)

pop_name_two = name_list.pop(0)
print(name_list)
print(pop_name_two)

"""run:
['测试划水老师傅', 'Python']
Java
['Python']
测试划水老师傅
"""

删除 remove()

移除列表中某个数据的第一个匹配项

python 复制代码 
"""
3.列表.remove(数据)
"""
name_list = ["测试划水老师傅","Python","Java"]
remove_one = name_list.remove("Java")
print(name_list)

"""run:
['测试划水老师傅', 'Python']
"""

删除 clear()

清空列表

python 复制代码 
"""
4.列表.clear() 清空列表
"""
name_list = ["测试划水老师傅","Python","Java"]
name_list.clear()
print(name_list)

"""run:
[]
"""

增加 append()

列表结尾追加数据

python 复制代码 
"""
1.列表序列.append(数据)
"""
name_list = ["Kevin","Tom","Jack"]
new_name_list = name_list.append("Bob")
print(name_list)
print(new_name_list)

#注意，append会修改原有列表数据
"""run:
['Kevin', 'Tom', 'Jack', 'Bob']
None
"""

增加 extend()

列表结尾追加数据，如果数据是一个序列，则将这个序列的数据，逐一添加到列表

python 复制代码 
"""
2.列表序列.extend(数据)
"""
name_list = ["Kevin","Tom","Jack"]
new_name_list = name_list.extend("Bob")
print(name_list)
print(new_name_list)
name_list.extend(["AA","BB"])
print(name_list)

#注意：
#1. extend会修改原有列表数据
#2. 会将序列的额数据，注意添加到列表，下方显示字符串、列表添加后的结果     
"""run:
['Kevin', 'Tom', 'Jack', 'B', 'o', 'b']
None
['Kevin', 'Tom', 'Jack', 'B', 'o', 'b', 'AA', 'BB']
"""

增加 insert()

指定位置新增数据

python 复制代码 
"""
3.列表序列.insert(位置下标,数据)
"""
name_list = ["Kevin","Tom","Jack"]
new_name_list = name_list.insert(0,"Bob")
print(name_list)
print(new_name_list)

#注意：
#1. insert会修改原有列表数据    
"""run:
['Bob', 'Kevin', 'Tom', 'Jack']
None
"""

修改指定下标数据

python 复制代码 
"""
1.修改指定下标的数据
"""
name_list = ["测试划水老师傅","Python","Java"]
name_list[0] = "老师傅去划水"
print(name_list)

"""run:
['老师傅去划水', 'Python', 'Java']
"""

逆置数据 reverse()

python 复制代码 
"""
2.逆序 reverse()
"""
id = [1,2,4,4,5,1]
id.reverse()
print(id)

"""run:
[1, 5, 4, 4, 2, 1]
"""

排序 sort()

python 复制代码 
"""
3.列表.sort(key=None, reverse=False)
注意：reverse表示排序规则 reverse=True 降序； reverse=False 升序（默认）
"""
id_sort = [1,2,4,4,5,1]
id_sort.sort()
print(id_sort)

"""run:
[1, 1, 2, 4, 4, 5]
"""

id_sort_True = [1,2,4,4,5,1]
id_sort_True.sort(reverse = True)
print(id_sort_True)

"""run:
[5, 4, 4, 2, 1, 1]
"""

复制 copy()

保留原始数据基础上，进行复制数据，一般原始数据不做操作

python 复制代码 
"""
1.列表.copy()
"""
name_list = ["测试划水老师傅","Python","Java"]
new_name_list = name_list.copy()
print(name_list)
print(new_name_list)

"""run:
['测试划水老师傅', 'Python', 'Java']
['测试划水老师傅', 'Python', 'Java']
"""

遍历 while & for

python 复制代码 
"""
1.while循环遍历
"""
name_list = ["测试划水老师傅","Python","Java"]
i = 0
while i < len(name_list):
    print(name_list[i])
    i += 1
"""run:
测试划水老师傅
Python
Java
"""


"""
2.for循环遍历
"""
name_list = ["测试划水老师傅","Python","Java"]
for i in name_list:
    print(i)

"""run:
测试划水老师傅
Python
Java
"""

列表嵌套

python 复制代码 
name_list = [["测试划水老师傅","Python","Java"],["C","C#","Go"],["PHP","JS","C++"]]
print(name_list[0])
print(name_list[0][1])

"""run:
['测试划水老师傅', 'Python', 'Java']
Python
"""

练习题

python 复制代码 
"""
练习题：
有三个办公室，8位老师，8个老师随机分配到3个办公室
1. 准备数据
    1.1 8位老师 -- 列表
    1.2 3个办公室 -- 列表嵌套
2. 分配老师到办公室
    *** 随机分配
    把老师的名字写入到办公室列表 -- 办公室列表追加老师数据
3. 验证是否分配成功
    打印办公室详细信息；每个办公室的人数和对应的老师名字
"""
import random

teachers = ["老师A","老师B","老师C","老师D","老师E","老师F","老师G","老师H"]
offices = [[],[],[]]
for teacher in teachers:
    num = random.randint(0,2)
    offices[num].append(teacher)
i = 1
for office in offices:
    print(f'办公室{i}的人数：{len(office)},办公室的老师有：')
    for teacher in office:
        print(teacher)
    i += 1

元组

python 复制代码 
t = (数据1,数据2,数据3.....)
  1. 元组可以存储多个数据
  2. 数据不能被修改
  3. 元组写法 t1=（10,）即如果只有一组数据，也需要在末尾添加","，多个数据写法：t2=(10,20)

根据下标查找列表元素

python 复制代码 
t1 = ("测试划水老师傅","Python","Java")
"""
1. 下标
"""
print(t1[0])

查找 index()

python 复制代码 
"""
2. index()
"""
print(t1.index("Python"))

统计 count()

python 复制代码 
"""
3. count()
"""
print(t1.count("Python"))

长度 len()

python 复制代码 
""
4. len()
"""
print(len(t1))

修改

元组类型数据无法修改，但元组内嵌套列表等可变类型数据，可修改可变类型数据

python 复制代码 
t1 = ("测试划水老师傅","Python","Java")
# t1[0] = "aaa" 元组不支持修改
t2 = ("测试划水老师傅",["Python","Java"])
print(t2[1])
print(t2[1][0])
t2[1][0] = "Tom"
print(t2)

"""run:
['Python', 'Java']
Python
('测试划水老师傅', ['Tom', 'Java'])
"""

字典

字典，字典里面的数据以键值对形式出现，字典数据和数据顺序没有关系，即字典不支持下标，只需要按照对应的键的名字查找数据即可。

python 复制代码 
d1 = {"测试划水老师傅":{"性别":"男","年龄":"30"}}
print(d1["测试划水老师傅"])
print(d1["测试划水老师傅"]["性别"])
"""run:
{'性别': '男', '年龄': '30'}
男
"""

增加

字典序列[key] = 值

python 复制代码 
d1 = {"测试划水老师傅":{"性别":"男","年龄":"30"}}
d1["ID"] = 110
print(d1)

"""run:
{'测试划水老师傅': {'性别': '男', '年龄': '30'}, 'ID': 110}
"""

删除 del()

del()：删除字典对象,或删除制定键值对

python 复制代码 
d1 = {"姓名":"测试划水老师傅","性别":"男","年龄":"30"}
del(d1)
print(d1)
"""run:
Traceback (most recent call last):
  File "E:/****/****/****/列表.py", line 4, in <module>
    print(d1)
NameError: name 'd1' is not defined
"""


d1 = {"姓名":"测试划水老师傅","性别":"男","年龄":"30"}
del d1["姓名"]
print(d1)
"""run:
{'性别': '男', '年龄': '30'}
"""

清空 clear()

clear()：清空字典数据,保留空字典

python 复制代码 
d2 = {"姓名":"测试划水老师傅","性别":"男","年龄":"30"}
d2.clear()
print(d2)
"""run:
{}
"""

修改

写法：字典序列[key] = 值 ，如果key存在修改，不存在则是新增

python 复制代码 
d1 = {"姓名":"测试划水老师傅","性别":"男","年龄":"30"}
d1["姓名"] = "python"
print(d1)
"""run:
{'姓名': 'python', '性别': '男', '年龄': '30'}
"""

查找 通过字典 key

python 复制代码 
d1 = {"姓名":"测试划水老师傅","性别":"男","年龄":"30"}
print(d1["姓名"])
"""run:
测试划水老师傅
"""

查找 get()

python 复制代码 
d1 = {"姓名":"测试划水老师傅","性别":"男","年龄":"30"}
print(d1.get("性别"))
print(d1.get("性别1","404"))
print(d1.get("性别1"))
"""run:
男
404
None
"""

查找 keys()

python 复制代码 
d1 = {"姓名":"测试划水老师傅","性别":"男","年龄":"30"}
print(d1.keys())
"""run:
dict_keys(['姓名', '性别', '年龄'])
"""

查找 values()

python 复制代码 
d1 = {"姓名":"测试划水老师傅","性别":"男","年龄":"30"}
print(d1.values())
"""run:
dict_values(['测试划水老师傅', '男', '30'])
"""

查找 items()

python 复制代码 
d1 = {"姓名":"测试划水老师傅","性别":"男","年龄":"30"}
print(d1.items())
"""run:
dict_items([('姓名', '测试划水老师傅'), ('性别', '男'), ('年龄', '30')])
"""

遍历

  • 遍历字典的key
  • 遍历字典的value
  • 遍历字典的元素
  • 遍历字典的键值对（拆包）
python 复制代码 
d1 = {"姓名":"测试划水老师傅","性别":"男","年龄":"30"}
for key in d1.keys():
    print(key)

print("__________________")

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

print("__________________")

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

print("__________________")

for key, value in d1.items():
    print(f"{key} = {value}")
    
"""run:
姓名
性别
年龄
__________________
测试划水老师傅
男
30
__________________
('姓名', '测试划水老师傅')
('性别', '男')
('年龄', '30')
__________________
姓名 = 测试划水老师傅
性别 = 男
年龄 = 30
"""

集合

特点：

集合具有将数据自动"去重"的效果。

创建集合

创建集合使用 {} 或者 set{}，但是如果要创建空集合只能使用set()，因为{} 是用来创建字典的。

python 复制代码 
s1 = {10, 20, 30, 40}
print(s1)

s2 = set("abcde")
print(s2)

s3 = set()
print(type(s3))

s4 = {}
print(type(s4))

"""run:
{40, 10, 20, 30}
{'d', 'b', 'e', 'a', 'c'}
<class 'set'>
<class 'dict'>
"""

追加 add()

add()，用来增加一个单一数据。

集合具有去重功能，所以，当向集合追加的数据已存在，则不进行任何操作。

python 复制代码 
s1 = {10, 20, 30, 40}
s1.add(15)
s1.add(10)
print(s1)
"""run:
{40, 10, 15, 20, 30}
"""

如果使用add()追加的是一个序列，则会报错。

python 复制代码 
s1 = {10, 20, 30, 40}
s1.add(50, 60)
print(s1)
"""run:
Traceback (most recent call last):
  File "E:\****\main.py", line 2, in <module>
    s1.add(50, 60)
TypeError: set.add() takes exactly one argument (2 given)
"""

追加 update()

追加的数据是序列。

python 复制代码 
s1 = {10, 20, 30, 40}
s1.update([10, 60, 70])
print(s1)
"""run:
{70, 40, 10, 20, 60, 30}
"""

非序列数据，会报错

python 复制代码 
s1 = {10, 20, 30, 40}
s1.update(100)
print(s1)
"""run:
Traceback (most recent call last):
  File "E:\****\main.py", line 2, in <module>
    s1.update(100)
TypeError: 'int' object is not iterable
"""

删除 remove()

删除集合中的指定数据，如果数据不存在则报错。

python 复制代码 
s1 = {10, 20, 30, 40}
s1.remove(10)
print(s1)
s1.remove(60)
print(s1)
"""run:
Traceback (most recent call last):
  File "E:\****\main.py", line 4, in <module>
    s1.remove(60)
KeyError: 60
{40, 20, 30}
"""

删除 discard()

删除集合中的指定数据，如果数据不存在也不会报错

python 复制代码 
s1 = {10, 20, 30, 40}
s1.discard(10)
print(s1)
s1.discard(60)
print(s1)
"""run:
{40, 20, 30}
{40, 20, 30}
"""

删除 pop()

随机删除集合中的某个数据，并返回这个数据。

python 复制代码 
s1 = {10, 20, 30, 40}
s1.pop()
print(s1)
"""run:
{10, 20, 30}
"""

对空集合进行pop操作，会报错。

python 复制代码 
s1 = {10, 20, 30, 40}
s1.pop()
s1.pop()
s1.pop()
s1.pop()
s1.pop()
print(s1)
"""run:
Traceback (most recent call last):
  File "E:\****\main.py", line 6, in <module>
    s1.pop()
KeyError: 'pop from an empty set'
"""

查找 in，not in

in 判断数据在集合序列。

not in 判断数据不在集合序列.

python 复制代码 
s1 = {10, 20, 30, 40}
print(10 in s1)
print(10 not in s1)
print(50 in s1)
"""run:
True
False
False
"""

数据类型转换

python 复制代码 
"""
1. input
2. 检测input的数据类型
3. 用方法转换数据类型
4. 检查是否转换成功
"""
your_input = input("请输入内容：")
print(f"你输入的内容是{your_input},输入的类型是{type(your_input)}")

int_type = int(your_input)
print(f"类型转换{int_type}：{type(int_type)}")

float_type = float(your_input)
print(f"类型转换{float_type}：{type(float_type)}")

str_type = str(your_input)
print(f"类型转换{str_type}：{type(str_type)}")

eval_type = eval(your_input)
print(f"类型转换{eval_type}：{type(eval_type)}")

tuple_type = tuple(your_input)
print(f"类型转换{tuple_type}：{type(tuple_type)}")

list_type = list(your_input)
print(f"类型转换{list_type}：{type(list_type)}")

"""
run result:
请输入内容：1234
你输入的内容是1234,输入的类型是<class 'str'>
类型转换1234：<class 'int'>
类型转换1234.0：<class 'float'>
类型转换1234：<class 'str'>
类型转换1234：<class 'int'>
类型转换('1', '2', '3', '4')：<class 'tuple'>
类型转换['1', '2', '3', '4']：<class 'list'>
"""

# eval是指将输入的字符串内容转换成原本的数据类型
your_input = "[1,2,3,4]"
eval_type = eval(your_input)
print(f"类型转换{eval_type}：{type(eval_type)}")

"""
run result:
类型转换[1, 2, 3, 4]：<class 'list'>
"""

数据的可变类型和不可变类型

  1. 可变的：列表、集合、字典（可以进行更改，并且更改后物理地址不会发生改变）
  2. 不可变的：数字(整型、浮点数)、字符串、元组（不可以进行更改，更改后就是一个新的对象了，物理地址发生了变化）
python 复制代码 
# 列表 可变类型,append数据后，内存地址依然没有变化。
list_a = [10, 20]
list_b = list_a
print(f'list_b的值{list_b}')
print(f'list_a的内存地址{id(list_a)}')
print(f'list_b的内存地址{id(list_b)}')
list_a.append(30)
print(f'list_b的值{list_b}')
print(f'list_a的内存地址{id(list_a)}')
print(f'list_b的内存地址{id(list_b)}')
"""run:
list_b的值[10, 20]
list_a的内存地址1873382598272
list_b的内存地址1873382598272
list_b的值[10, 20, 30]
list_a的内存地址1873382598272
list_b的内存地址1873382598272
"""
python 复制代码 
a = 10
b = a
print(f'a的值{a}')
print(f'a的内存地址{id(a)}')
print(f'b的内存地址{id(b)}')

a = 2
print(f'b的值{b}')
# 因为修改了a的数据，内存需要开辟新的地址存储
print(f'a的内存地址{id(a)}')
print(f'b的内存地址{id(b)}')
"""run:
a的值10
a的内存地址3115119477264
b的内存地址3115119477264
b的值10
a的内存地址3115119477008
b的内存地址3115119477264
"""

数据拆包

元组拆包

python 复制代码 
def return_str():
    return "测试划水老师傅", "30岁"

str_1, str_2 = return_str()
print(str_1)
print(str_2)
"""run:
测试划水老师傅
30岁
"""

字典拆包

python 复制代码 
dict_data = {"name": "测试划水老师傅", "age": "30岁"}
dict_1, dict_2 = dict_data
print(dict_1)
print(dict_2)
print(dict_data.get(dict_1))
print(dict_data.get(dict_2))
"""run:
name
age
测试划水老师傅
30岁
"""

四、print 输出

格式化输出

python 复制代码 
"""
1. 准备数据
2. 格式化符号输出数据
"""
age = 18
name = "Kevin"
weight = 75.5
stu_id = 13

# 1. 今年我的年龄是x岁。
print("今年我的年龄是%d岁。" % age)

# 2. 我的名字是x。
print("我的名字是%s。" % name)

# 3. 我的体重是x公斤。 %1f 表示保留1位小数
print("我的体重是%1f公斤。" % weight)#我的体重是75.500000公斤。
print("我的体重是%.1f公斤。" % weight)#我的体重是75.5公斤。

# 4. 我的学号是x。(要求，输出000000013)，
print("我的学号是%d。" %stu_id) #我的学号是13。
print("我的学号是%08d。" %stu_id) #我的学号是00000013（%08d不足8位，以0不全，超出当前位数则原样输出）

# 5. 我的名字是x，今年x岁了。
print("我的名字是%s，今年%d岁了。" %(name,age))

# 5.1. 我的名字是x，今年x岁了,明年x岁。
print("我的名字是%s，今年%d岁了，明年%d岁。" %(name,age,age+1))

# 6. 我的名字是x，今年x岁了，体重x公斤，学号是x。
print("我的名字是%s，今年%d岁了，体重%.1f公斤，学号是%08d。" %(name,age,weight,stu_id))

转义字符"\"

python 复制代码 
# 换行符 \n
print("第1行：测试划水老师傅。\n第2行：天天在摸鱼！")
# 制表符 \t （tab）
print("第1行：测试划水老师傅。\t第2行：天天在摸鱼！")
# \\ "\"字符
print("第1行：测试划水老师傅。\\第2行：天天在摸鱼！")
# \'字符 单引号
print("第1行：测试划水老师傅。\'第2行：天天在摸鱼！")
#\t：制表符，一个tab键（4个空格）的距离
print("A\tB\tC\tD\tE\tF\tG")

结束符

python 复制代码 
print("Hello",end="\t")#结束符
print("World")
#Hello    World

五、运算符

  • 算数运算符
  • 赋值运算符
  • 复合赋值运算符
  • 比较运算符
  • 逻辑运算符

算数运算符

运算符 描述 实例
+ 加 1+1 输出结果为 2
- 减 1-1 输出结果为 0
* 乘 2*2 输出结果为 4
/ 除 10/2 输出结果为 5
// 整除 9//4 输出结果为 2
% 取余 9%4 输出结果为 1
** 指数 2 ** 4 输出结果为 16，即 222*2
() 小括号 小括号用来提高运算优先级，即（1+2）*3 输出结果为9

注意：

  • 混合运算优先级顺序：()高于**高于*///%高于±
    | 运算符 | 描述 | 支持的容器类型 |
    | --- | --- | --- |
    | + | 合并 | 字符串、列表、元组 |
    | * | 复制 | 字符串、列表、元组 |
    | in | 元素是否存在 | 字符串、列表、元组、字典 |
    | not in | 元素是否不存在 | 字符串、列表、元组、字典 |

赋值运算符

运算符 描述 实例
= 赋值 将=右侧的结果赋值给符号左侧的变量
python 复制代码 
# 单个变量赋值
num = 1
print(num)

# 多个变量赋值
num_1, float_2, str_3 = 10, 0.5, "HelloWorld"
print(num)
print(float_2)
print(str_3)

# 多个变量赋值相同值
a = b = 10
print(a)
print(b)

"""run:
ABCabc
ABCABC
True
True
[1, 2, 3, 4, 5, 6, 7, 8]
[1, 2, 3, 4, 1, 2, 3, 4]
True
False
(9, 10, 11, 12, 13, 14, 15, 16)
(9, 10, 11, 12, 9, 10, 11, 12)
True
False
"""

复合赋值运算符

运算符 描述 实例
+= 加法赋值运算符 c += a 等价于 c = c+a
-= 减法赋值运算符 c -= a 等价于 c = c -a
*= 乘法赋值运算符 c *= a 等价于 c = c *a
/= 除法赋值运算符 c/=a 等价于 c=c/a
//== 整除赋值运算符 c//a 等价于 c=c//a
%= 取余赋值运算符 c%=a 等价于 c=c%a
**= 幂赋值运算符 c**=a 等价于 c=c**a

比较运算符

运算符 描述
== 判断相等。如果两个操作数的结果相等，则条件结果为真（True），否则条件结果为假（False）
!= 不等于。如果两个操作数的结果不相等，则条件结果为真（True），否则条件结果为假（False）
> 运算符左侧操作数结果是否大于右侧操作结果数，如果大于，则条件为真，否则为假
< 运算符左侧操作数结果是否小于右侧操作结果数，如果小于，则条件为真，否则为假
>= 运算符左侧操作数结果是否大于等于右侧操作结果数，如果大于等于，则条件为真，否则为假整除赋值运算符
<= 运算符左侧操作数结果是否小于等于右侧操作结果数，如果小于等于，则条件为真，否则为假整除赋值运算符
**= 幂赋值运算符

逻辑运算符

if

python 复制代码 
"""
if 条件:
    条件成立执行的代码1
    条件成立执行的代码2
"""
if True:
    print("条件成立执行代码-1")
    print("条件成立执行代码-2")

if False:
    print("条件成立执行代码-3")
print("条件不成立执行代码-4")

"""
run result:
条件成立执行代码-1
条件成立执行代码-2
条件不成立执行代码-4
"""

if...else

python 复制代码 
"""
if 条件:
    条件成立执行的代码-1
    条件成立执行的代码-2
else:
    条件不成立执行的代码-3
    条件不成立执行的代码-4
"""

if False:
    print("条件成立执行的代码-1")
    print("条件成立执行的代码-2")
else:
    print("条件不成立执行的代码-3")
    print("条件不成立执行的代码-4")
    
"""
run result：
条件不成立执行的代码-3
条件不成立执行的代码-4
"""

if...elif...else

python 复制代码 
"""
if 条件:
    条件1成立执行的代码-1
    条件1成立执行的代码-2
elif 条件2:
    条件2成立执行的代码-3
    条件2成立执行的代码-4
else:
    以上条件都不成立执行的代码
"""
age = int(input("请输入您的年龄："))
if (age >= 18) and (age <= 60):
    print(f"{age}岁符合中国合法工作年龄")
elif age < 18:
    print(f"您的年龄{age}过小，不符合中国合法工作年龄要求")
else:
    print(f"您的年龄{age}过大，不符合中国合法工作年龄要求")
print("程序执行结束！")

if 嵌套

python 复制代码 
"""
if 条件:
    条件1成立执行的代码-1
    条件1成立执行的代码-2
    if 条件2:
        条件2成立执行的代码-3
        条件2成立执行的代码-4
"""
money = input("您是否有钱坐公交？[是/否]")
if money == "是":
    print("您有钱，可以坐公交！")
    seat = input("公交车是否有空座？[是/否]")
    if seat == "是":
        print("公交车上有座位，您可以坐在座位上！")
    else:
        print("公交车上没有座位，您只能站着坐公交！")
else:
    print("您没有钱，不可以坐公交！")
"""
run result：
您是否有钱坐公交？[是/否]是
您有钱，可以坐公交！
公交车是否有空座？[是/否]是
公交车上有座位，您可以坐在座位上！
"""
python 复制代码 
"""
1.出拳：
    玩家：手动输入
    电脑：1.固定：出剪刀 2.随机
2.判断输赢：
    2.1玩家获胜
    2.2平局
    2.3电脑获胜
"""
import random
#1. 出拳
#玩家出拳
player = int(input("请出拳：（0--石头；1--剪刀；2--布）"))
#电脑出拳
computer = random.randint(0,2)

#2.判断输赢
#玩家获胜
if ((player == 0) and (computer == 1)) or ((player == 1) and (computer == 2)) or ((player == 2) and (computer == 0)):
    print("玩家获胜！")
#平局
elif player == computer:
    print("别走，再来一局！")
else:
    print("电脑获胜！")

三目运算符

python 复制代码 
"""
化简if....else
写法：
条件成立执行的表达式 if 条件 else 条件不成立执行的表达式
"""
a = 1
b = 2
c = a if a > b else b
print(c)

while循环

python 复制代码 
"""
while循环初了解
"""
#循环5次我是Bob
i = 0
while i < 5:
    print("我是bob。")
    i += 1
python 复制代码 
"""
1-100的累加和
"""
i = 0
result = 0
while i <= 100:
    result += i
    i += 1
print(result)
python 复制代码 
"""
1-100的偶数累加和 if方法
"""
i = 0
result = 0
while i <= 100:
    if i % 2 == 0:
        result = result + i
    i += 1
print(result)

"""
1-100的偶数累加和 计数器方法
"""
i = 0
result = 0
while i <= 100:
    result = result + i
    i += 2
print(result)

for 循环

python 复制代码 
"""
for 临时变量 in 序列：
    重复执行的代码1
    重复执行的代码2
    ......
"""
str_1 = "My name is Python"
for i in str_1:
    print(i)

六、推导式

列表推导式

作用：用一个表达式创建一个有规律的列表或控制一个有规律的列表

列表推导式又叫列表生成式。

python 复制代码 
# 快速创建一个0-10的列表
# while实现
list_1 = []
i = 0
while i <= 10:
    list_1.append(i)
    i += 1
print(list_1)

# 使用for实现
list_2 = []
for i in range(11):
    list_2.append(i)
print(list_2)

# 使用列表推导式完成
list_3 = [i for i in range(11)]
print(list_3)

# 列表推导式中存在if判断,输出偶数
list_4 = [i for i in range(11) if i % 2 == 0]
print(list_4)
"""run:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[0, 2, 4, 6, 8, 10]
"""
python 复制代码 
# 多个for循环实现列表推导式
# 打印：[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

list_1 = []
for i in range(1, 3):
    for j in range(3):
        list_1.append((i, j))
print(list_1)

list_2 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list_2)

字典推导式

快速合并列表为字典或提取字典中目标数据。

python 复制代码 
# 创建一个字典：字典的key是1-5数字，value是这个数字的平方。
dict_1 = {i: i ** 2 for i in range(1, 5)}
print(dict_1)

# 将两个列表合并成一个字典
list_1 = ["name", "age", "gender"]
list_2 = ["测试划水老师傅", "30", "男"]
dict_2 = {list_1[i]: list_2[i] for i in range(len(list_1))}
print(dict_2)
"""run:
{1: 1, 2: 4, 3: 9, 4: 16}
{'name': '测试划水老师傅', 'age': '30', 'gender': '男'}
"""
"""
总结：
	● 如果两个列表数据个数相同，len统计任何一个列表长度都可以。
	● 如果两个列表个数不同，len统计数据多的列表个数会报错，len统计数据少的列表数据个数则不会报错。
"""

提取字典中目标数据

python 复制代码 
counts = {"Python": 12, "Java": 10, "Go": 5}
# 提取上述班级内学习编程语言人数大于10人的字典数据
count_1 = {key: value for key, value in counts.items() if value >= 10}
print(count_1)
"""run:
{'Python': 12, 'Java': 10}
"""

集合推导式

快速创建一个集合

python 复制代码 
# 快速创建一个集合，数据为[1,1,2]的2次方
list_1 = [1, 1, 2]
# 注意，集合有去重的功能
set_1 = {i ** 2 for i in list_1}
print(set_1)
"""run:
{1, 4}
"""

七、函数

函数的作用

函数就是将一段具有独立功能的代码块整合到一个整体并命名，在需要的位置调用这个名称即可完成对应的需求。

函数在开发过程中，可以更高效的实现代码重用。

python 复制代码 
# Step1：先定义函数
def print_hello():
    print("Hello")


# Step2：再调用函数
print_hello()
"""run:
Hello
"""

函数的参数

python 复制代码 
"""
函数：固定计算 1 和2 的加法
"""
def add_num():
    print(1 + 2)

add_num()

"""
函数：命名形参（函数参数为占位符），接收调用函数时，实际传入的参数（实参），可以实现任意数字的加法运算。
"""
def add_num_plus(a, b):
    print(a + b)

add_num_plus(1, 2)

位置参数

调用函数时根据函数定义的参数位置来传递参数。

:::info

注意：传递和定义的参数的顺序及个数必须一致

:::

python 复制代码 
def user_info(name, age, sex):
    print(f"姓名：{name}，年龄{age}，性别{sex}")

user_info("测试划水老师傅", 30, "男")
"""run:
姓名：测试划水老师傅，年龄30，性别男
"""

关键字参数

函数调用，通过"键 = 值"的形式指定。可以让函数更加清晰、容易使用，同时不需要注意函数的顺序。

python 复制代码 
def user_info(name, age, sex):
    print(f"姓名：{name}，年龄{age}，性别{sex}")

user_info(age=30,name="测试划水老师傅",sex="男")
"""run:
姓名：测试划水老师傅，年龄30，性别男
"""

缺省参数

也叫默认参数，用于定义函数，为参数提供默认值，调用函数时，可以不传入该默认参数的值。

:::info

注意：所有位置参数必须卸载默认参数前，包括函数定义和调用

:::

python 复制代码 
def user_info(name, age, sex="男"):
    print(f"姓名：{name}，年龄{age}，性别{sex}")

user_info(age=30,name="测试划水老师傅")
"""run:
姓名：测试划水老师傅，年龄30，性别男
"""

不定长参数-位置参数

也叫可变参数。用于不确定调用时会会传入多少个参数（不传参数也可以）的场景。此时，用包裹（packing）位置的参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。

:::info

注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组（tuple），args是元组类型，这就是包裹位置传递。

:::

python 复制代码 
def user_info(*args):
    print(args)

user_info("测试划水老师傅", 30)
"""run:
('测试划水老师傅', 30)
"""

不定长参数-关键字参数

收集所有关键字参数，返回一个"字典"

python 复制代码 
def user_info(**kwargs):
    print(kwargs)

user_info(name = "测试划水老师傅", age = 30)
"""run:
{'name': '测试划水老师傅', 'age': 30}
"""

:::info

不定长参数"位置参数"、"关键字参数"，无论是包裹位置还是包裹关键字传递，都是一个组包的过程。

:::

函数的返回值

例如：我们去书店购买书籍《Python核心编程》，付钱后，书店会将该书籍返回给你，在函数中，如果需要返回函数结果，需要使用return。

python 复制代码 
def shoopping():
    return "《Python核心编程》"

goods = shoopping()
print(goods)

return的特点：

  1. 返回函数结果。
  2. return运行后，该函数结束，即return后编写代码不执行。

返回值作为参数传递：

python 复制代码 
def test_A():
    str = "Python"
    return str

def test_B(book):
    print(book)

result = test_A()
test_B(result)
"""run:
Python
"""

return 多个数据，并且定义返回的数据类型

python 复制代码 
def test_A():
    str_1 = "Python"
    str_2 = "Java"
    return str_1, str_2

def test_B():
    str_1 = "Python"
    str_2 = "Java"
    return (str_1, str_2)

def test_C():
    str_1 = "Python"
    str_2 = "Java"
    return [str_1, str_2]

def test_D():
    str_1 = "Python"
    str_2 = "Java"
    return {"key1":str_1,"key2":str_2}

def test_E():
    str_1 = "Python"
    str_2 = "Java"
    return f"{str_1}、{str_2}"

def print_return(book):
    print(book)

result_1 = test_A()
print(result_1)
print(type(result_1))
result_2 = test_B()
print(result_2)
print(type(result_2))
result_3 = test_C()
print(result_3)
print(type(result_3))
result_4 = test_D()
print(result_4)
print(type(result_4))
result_5 = test_E()
print(result_5)
print(type(result_5))

"""run:
('Python', 'Java')
<class 'tuple'>
('Python', 'Java')
<class 'tuple'>
['Python', 'Java']
<class 'list'>
{'key1': 'Python', 'key2': 'Java'}
<class 'dict'>
Python、Java
<class 'str'>
"""

函数的说明文档

python 复制代码 
def shoopping():
    """
    这是一个介绍return的简单函数
    :return: "《Python核心编程》"
    """
    return "《Python核心编程》"

help(shoopping)
"""run:
Help on function shoopping in module __main__:

shoopping()
    这是一个介绍return的简单函数
    :return: "《Python核心编程》"
"""

函数嵌套

指一个函数里面又调用另外一个函数。

python 复制代码 
def shoopping(book_name):
    """
    这是一个介绍return的简单函数
    :return: "《Python核心编程》"
    """
    return "《Python核心编程》"


def need_pay_num(book_name):
    if book_name == "《Python核心编程》":
        return "你需要支付60元"

print(shoopping("《Python核心编程》"))
print(need_pay_num("《Python核心编程》"))

练习

python 复制代码 
def print_line():
    print("-" * 20)


print_line()


def print_lines(num):
    i = 0
    while i < num:
        print_line()
        i += 1

print_lines(3)
"""run:
--------------------
--------------------
--------------------
--------------------
"""

变量的作用域与函数的关系

变量作用域指的是变量生效的范围，主要分为两类：局部变量和全局变量。

局部变量

局部变量是定义在函数体内的变量，只在函数体内部生效，如果在函数体外使用，则代码报错。

局部变量的作用：

  • 在函数体内部，临时保存数据，当函数体调用完成后，局部变量被销毁。
python 复制代码 
def testA():
    a = "测试划水老师傅"
    print(a)

testA()
print(a)
"""run:
测试划水老师傅
Traceback (most recent call last):
  File "E:\****\test.py", line 6, in <module>
    print(a)
NameError: name 'a' is not defined
"""

全局变量

全局变量，指在函数体内、外都能生效的变量。

python 复制代码 
a = "测试划水老师傅"
def testA():
    print(a)

testA()
print(a)
"""run:
测试划水老师傅
测试划水老师傅
"""

如果另外一个函数内使用"局部变量"修改"全局变量"会有什么变化？

python 复制代码 
a = "测试划水老师傅"
def testA():
    print(a)

def testB():
    a = "Python"
    print(a)
testA()
testB()
print(f'全局变量a = {a}')
"""run:
测试划水老师傅
Python
全局变量a = 测试划水老师傅
"""

利用global关键字，修改全局变量

python 复制代码 
a = "测试划水老师傅"
def testA():
    print(a)

def testB():
    global a
    a = "Python"
    print(a)
testA()
testB()
print(f'全局变量a = {a}')
"""run:
测试划水老师傅
Python
全局变量a = Python
"""

多函数程序执行流程

一个功能（程序），都是有多个函数组成，相互调用，多个函数也会共用一些数据。

python 复制代码 
glo_str = "测试划水老师傅"

def test_A():
    global glo_str
    # 修改全局变量
    glo_str = "Python"

def test_B():
    # 调用test_A函数中修改后的全局变量
    print(glo_str)

# 未调用函数test_A，全局变量使用未修改前的数据
print(glo_str)

# test_A函数，执行内部代码，声明和修改全局变量
test_A()

# test_B函数，执行打印
test_B()

# 再次直接打印全局变量，此时已经修改
print(glo_str)

"""run:
测试划水老师傅
Python
Python
"""

函数练习题-1

需求：

进入系统显示系统功能页面，功能列表如下：

  1. 添加学员
  2. 删除学员
  3. 修改学员信息
  4. 查询学员信息
  5. 显示所有学员信息
  6. 退出系统

系统共6个功能，用户根据自己需求选取。

:::success

实现步骤解析

  1. 显示功能界面
  2. 用户输入"功能序号"。
  3. 根据用户输入的功能序号，执行不同的业务（函数）。
    1. 定义函数
    2. 调用函数
      :::
python 复制代码 
"""
需求：
进入系统显示系统功能页面，功能列表如下：
1. 添加学员
2. 删除学员
3. 修改学员信息
4. 查询学员信息
5. 显示所有学员信息
6. 退出系统
系统共6个功能，用户根据自己需求选取。
"""


def print_app_info():
    print("""_____________________________
请选择系统功能（功能序号）>>>>>>>：
1. 添加学员
2. 删除学员
3. 修改学员信息
4. 查询学员信息
5. 显示所有学员信息
6. 退出系统
_____________________________            
    """)


# 存储学员信息列表
students_list = []


def add_student():
    """
    添加学员函数
    :return:
    """
    # 1.用户输入学员信息
    new_id = input("请输入学号：")
    new_name = input("请输入姓名：")
    new_age = input("请输入年龄：")
    # 2.判断添加的学员ID和姓名是否存在，如果已存在给与友好提示，如果不存在则添加数据。
    global students_list
    for i in students_list:
        if new_id == i['id']:
            print("ID重复，请重新输入！")
            return
        elif new_name == i['name']:
            print("学员姓名重复，请重新输入！")
            return
    student_dict = {"id": new_id, "name": new_name, "age": new_age}
    students_list.append(student_dict)


def del__student():
    """
    删除学员
    :return:
    """
    del_id = input("请输入删除的学员学号：")
    for i in students_list:
        if del_id == i['id']:
            students_list.remove(i)
            break
    else:
        print("学员ID不存在！")


def update_student():
    """
    修改学员信息
    :return:
    """
    update_id = input("请输入修改的学员学号：")
    for i in students_list:
        if update_id == i['id']:
            update_name = input("请输入姓名：")
            update_age = input("请输入年龄：")
            i['name'] = update_name
            i['age'] = update_age
            break
    else:
        print("学员ID不存在！")


def select_student():
    """
    查询学员信息
    :return:
    """
    select_id = input("请输入查询的学员学号：")
    for i in students_list:
        if select_id == i['id']:
            print(i)
            break
    else:
        print("学员ID不存在！")


def show_students():
    if len(students_list) == 0:
        print("请添加学员信息！")
    else:
        for i in students_list:
            print(i)


while True:
    print_app_info()
    app_num = int(input("请输入功能序号："))
    if app_num == 1:
        add_student()
    elif app_num == 2:
        del__student()
    elif app_num == 3:
        update_student()
    elif app_num == 4:
        select_student()
    elif app_num == 5:
        show_students()
    elif app_num == 6:
        print("退出系统成功！")
        break
    else:
        print("输入错误请重新输入！")

递归

递归属于一种编程思想。

递归的应用场景：

  1. 日常开发中，如果要遍历一个文件夹下所有文件，通常会使用递归来实现。
  2. 算法中，很多都离不开递归，例如"快速排序"。
  3. 爬虫程序中，经常用到递归思想。

递归的特点：

  1. 函数内部自己调用自己。
  2. 必须有出口。（没有出口，可能会形成死循环或者报错提示"超出最大递归深度"！）

[Previous line repeated 996 more times]

RecursionError: maximum recursion depth exceeded

python 复制代码 
"""
利用递归实现1+2+3+4.....100
"""

def sum_numbers(num):
    # 1.如果是1，直接返回1 --出口
    if num == 1:
        return 1
    # 2.如果不是1，重复执行累加并返回结果
    return num + sum_numbers(num - 1)

sum_result = sum_numbers(100)
print(sum_result)

lambda表达式

应用场景：如果一个函数有一个返回值，并且只有一句代码，就可以使用lambda简化代码。

语法：

:::success

lambda 参数列表 : 表达式

:::

注意：

  • lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用。
  • lambda表达式能接收任何数量的参数，但只能返回一个表达式的值。
python 复制代码 
# 函数
def function_1():
    return 100
print(function_1)
print(function_1())

# lambda表达式写法
function_2 = lambda: 100
print(function_2)
print(function_2())
"""run:
<function function_1 at 0x00000208FAA43E20>
100
<function <lambda> at 0x00000208FADD7AC0>
100
"""

携带参数写法

python 复制代码 
# 函数
def add_test_1(a, b):
    return a + b


result = add_test_1(1, 2)
print(result)

# lambda表达式写法
add_test_2 = lambda a, b: a + b
print(add_test_2(1, 2))
"""run:
3
3
"""

参数用法与函数一致

python 复制代码 
# 无参数
print((lambda: 100)())
# 一个参数
print((lambda x: x)(200))
# 默认参数
print((lambda x=300: x)(300))
# 可变参数 **args
print((lambda *args: args)(1, 2, 3, 4))
print((lambda **kwargs: kwargs)(name="划水哥", age="30"))
"""run:
100
200
300
(1, 2, 3, 4)
{'name': '划水哥', 'age': '30'}
"""

判断写法

python 复制代码 
function_1 = lambda a, b: a if a > b else b
print(function_1(1, 2))
"""run:
2
"""

排序写法

python 复制代码 
# 按照列表字典中的某个值进行排序
students = [
    {'name': '刘德华', 'age': 18},
    {'name': '划水哥', 'age': 30}
]
# 升序排列
students.sort(key=lambda x: x['age'])
print(students)

# 降序排列
students.sort(key=lambda x: x['age'],reverse=True)
print(students)

高阶函数

定义：把函数作为参数传入，这样的函数称之为高阶函数。高阶函数时函数式编程的体现。函数式编程就是指这种高度抽象的编程范式。

作用：

  • 化简代码，增加代码的灵活性。
  • 函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快。
python 复制代码 
# abs()函数可以完成对数字求绝对值计算。
print(abs(-10))
# round()函数可以完成对数字的四舍五入计算。
print(round(1.2))
print(round(1.9))

"""高阶函数的写法"""


# 写法1.将两个绝对值相加
def add_num_abs(a, b):
    return abs(a) + abs(b)


result = add_num_abs(-1, 2)
print(result)


# 写法2.增加第3个参数，用来接收函数(这里传入的是函数名而不是传入带abs()的函数调用)
def add_num(a, b, f):
    return f(a) + f(b)


result_1 = add_num(-1, -4, abs)
result_2 = add_num(1.2, 1.6, round)
print(result_1)
print(result_2)
"""run:
10
1
2
3
5
3
"""

内置高阶函数：Map()

map(func, list)，将传入的函数变量func作用到list变量的每个元素中，并将结果组成新的迭代器(py3)返回。、

python 复制代码 
"""
计算list_1序列中各个数字的2次方
"""
list_1 = [1, 2, 3, 4]


def func(x):
    return x ** 2


result = map(func, list_1)
print(result)
print(list(result))
"""run:
<map object at 0x000002DF73807D90>
[1, 4, 9, 16]
"""

内置高阶函数：reduce()

reduce(func(x, y), list)，其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累积计算。

python 复制代码 
"""
计算list_1序列中各个数字的累加和
"""
import functools

list_1 = [1, 2, 3, 4]


def func(a, b):
    return a + b


result = functools.reduce(func, list_1)
print(result)
"""run:
10
"""

内置高阶函数：filter()

filter(func, list)函数用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象。如果要转换为列表，可以使用list()来转换。

python 复制代码 
"""
过滤获取列表中所有str类型的数据
"""

list_1 = [1, 2, 3, 4, "1"]


def func(x):
    return type(x) == str


result = filter(func, list_1)
print(result)
print(list(result))
"""run:
<filter object at 0x0000019CAF4B7D90>
['1']
"""

八、文件操作

文件操作的作用

什么是文件？

如果对于编程不了解的新手，很可能会认为文件只是单指txt，但其实文件在互联网中指的是所有存储数据的文件，例如"视频（MP4等）、"图片(PNG等)、"pdf、excel、word"、".json"等等。

文件操作都有哪些？

其实和你在windos打开文件一样，包含"打开、关闭、读、写、复制等等"

文件的基本操作

使用函数open，可以打开一个已经存在的文件，或者创建一个新文件，语法如下：

:::tips

open(name, mode)

:::

name：是要打开的目标文件名的字符串（"绝对路径"或者"相对路径"）

mode：设置打开文件的模式（访问模式）：只读，写入，追加等。

mode 描述
r（重点掌握） 以只读的方式打开文件。文件的指针将会放在文件的开头。这个是默认模式
rb 以二进制格式打开一个文件用于只读。文件指针会放在文件的开头。这是默认模式
r+ 打开一个文件用于读写。文件指针会放在文件的开头
rb+ 以二进制格式打开一个文件用于读写。文件指针会放在文件的开头。
w（重点掌握） 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被清空。如果该文件不存在，创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被清空。如果该文件不存在，创建新文件。
w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被清空。如果该文件不存在，创建新文件。
wb+ 以二进制打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被清空。如果该文件不存在，创建新文件。
a（重点掌握） 打开一个文件用于追加。如果该文件已存在，文件指针会放在文件的结尾。新的内容将会被写到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab 以二进制打开一个文件用于追加。如果该文件已存在，文件指针会放在文件的结尾。新的内容将会被写到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写
ab+ 以二进制打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写

文件的创建和写入

python 复制代码 
# 1、文件的创建（文件未存在，创建文件）/打开（文件已存在，为打开文件）
file = open('测试划水老师傅.txt', mode='w')
print(file.name)
# 2、文件内容写入
file.write("Test")
# 3、关闭文件
file.close()
"""run:
测试划水老师傅.txt
"""
python 复制代码 
# 如果文件不存在，使用只读模式打开文件，会提示报错
file = open('文件不存在.txt', mode='r')
"""run:
FileNotFoundError: [Errno 2] No such file or directory: '文件不存在.txt'
"""
python 复制代码 
# 文件内容追加（文件未存在，创建文件）/打开（文件已存在，为打开文件）
file = open('测试划水老师傅.txt', mode='a', encoding='utf-8')
file.write("追加的内容XXXX")
file.close()
python 复制代码 
# 省略访问模式,文件必须存在且不支持写入操作
file = open('测试划水老师傅.txt')
file.close()
"""run:
FileNotFoundError: [Errno 2] No such file or directory: 'test.txt'
"""

文件的读取

python 复制代码 
"""
文件对象.read(num)
num 表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么久表示读取文件中所有的数据
"""
file = open('测试划水老师傅.txt', 'r', encoding='utf-8')
read_result = file.read()
print(read_result)
file.close()
"""run:
张三
李四
王五
王麻子
"""
python 复制代码 
#访问字节数共4个，张三的后面其实隐藏携带了一个换行符"/n"所以为3个字符，导致"李四"的"四"未输出。
file_num = open('测试划水老师傅.txt', 'r', encoding='utf-8')
read_result_num = file_num.read(4)
print(read_result_num)
file_num.close()
"""run:
张三
李
"""
python 复制代码 
"""
文件对象.readlines()
可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。
"""
file_readlines = open('测试划水老师傅.txt','r',encoding='utf-8')
readlines_result = file_readlines.readlines()
print(readlines_result)
file_readlines.close()
"""run:
['张三\n', '李四\n', '王五\n', '王麻子']
"""
python 复制代码 
"""
文件对象.readline()
一次读取一行的内容
"""
file_readline = open('测试划水老师傅.txt','r',encoding='utf-8')
readline_result = file_readline.readline()
print(readline_result)
file_readline.close()
"""run:
张三
"""

文件指针操作seek()

python 复制代码 
"""
文件对象.seek(偏移量, 起始位置)
用来移动文件指针
起始位置：
    -0文件开头
    -1当前位置
    -2文件结尾
"""
# r 改变文件指针位置，即改变开始读取位置，从第3个数据开始读取
file = open('测试划水老师傅.txt', 'r+')
file.seek(2, 0)
res = file.read()
print(res)
file.close()

练习题-备份文件

python 复制代码 
"""
需求：用户输入当前目录下任意文件名称，程序完成对该文件的备份功能，备份名称为"xxx[备份].后缀，例如"划水老师傅[备份].txt""
"""
file_name = input("请输入需要备份的文件名称，例如：划水老师傅.txt")
index = file_name.find('.')
# 判断，如果没有.表示是一个无效文件。
if index > 0:
    fix = file_name[index:]
backup_file_name = file_name[:index] + '[备份]' + fix

# 打开文件
old_file = open(file_name, 'rb')
new_file = open(backup_file_name, 'wb')

# 将待备份文件内容写入备份文件,不确定目标文件大小，比如5G大小的数据，可以循环读取固定字节数
while True:
    context = old_file.read(1024)
    # 如果读取的数据为0表示已读取完所有数据，此时要退出循环。
    if len(context) == 0:
        break
    else:
        new_file.write(context)
old_file.close()
new_file.close()

文件和文件夹的操作

OS模块的详细文档可以进入文档菜单"模块-OS"详细学习

python 复制代码 
"""
1.导入模块 os
2.使用模块内功能，对文件及文件夹操作
"""
import os

# 1.rename(): 重命名文件名称或文件夹名称
os.rename('划水老师傅.txt', '重命名划水老师傅.txt')
os.rename('test', 'tests')
# 2.remove(): 删除文件或文件夹
os.remove('重命名划水老师傅.txt')
os.remove('test')
python 复制代码 
import os

# 创建文件夹
os.mkdir("Test")
# 删除文件夹
os.rmdir('Test')
python 复制代码 
import os

# 获取当前路径
os.getcwd()
# 改变默认目录
os.mkdir("a")
os.chdir("a")
os.mkdir("b")
python 复制代码 
import os

#获取目录列表 获取某个文件夹下所有文件，返回一个列表
print(os.listdir('a'))

九、面向对象

面向对象基础知识

类是对一些列具有相同特征和行为的事物的抽象概括统称。类可以用来创建对象。

  • 特征------行为
  • 行为------方法

比如工厂在制造电脑时，需要用到的图纸，根据图纸制作出一台电脑。

图纸------>类

电脑------>对象，是类创建出来真实存在的事物。

开发过程中，一定是先有类，再有对象

定义类

类名需要遵循大驼峰命名规则

python 复制代码 
class 类名():
    代码
    ......
python 复制代码 
"""
这是一个Person类
"""
class Person:

    def __init__(self, name, sex, id_card):
        """
        :param name:类属性"姓名"
        :param sex:类属性"性别"
        :param id_card:类属性"身份证号"
        魔法方法：__init__
        类的构造方法：类的一个特殊方法。
        特性：
            1.实例化一个对象时，这个方法就会在对象被创建时自动调用。
            2.实例化对象时，必须要根据实例方法中的形参传入对应实参。
        举例：
            比如人应该具备姓名、性别、身份证号。
            那么我实例化一个对象后，就该具备这些。
            （不用考虑什么刚出生婴儿没有身份证之类的抬杠想法......因为我也有考虑过，如果需要考虑到这么细致，可以自己修改构造方法。）
        """
        self.name = name
        self.sex = sex
        self.id_card = id_card
        
    def __str__(self):
        """
        :return:
        魔法方法：__str__
        类中未定义__str__方法，使用print打印实例对象，打印的是对象的内存地址。
        类中定义了__str__方法，使用print打印实例对象，打印的是__str__的返回值。
        """
        return "这是一个Person类"

    def print_person_info(self):
        """
        :return:
        实例方法（类方法）
        规则：
            1.首字母小写，驼峰式命名（全部小写，中间用英文下划线连接）
        特性：
            1.实例化一个对象后，可以调用类方法（行为）
        举例：
            比如一个人实例化后，就能够说出自己的姓名、性别、身份证号。
        self：
            1.指调用该函数的对象。
            2.通过self可以在类里面获取类属性。
        """
        print(f'姓名：{self.name}\n性别：{self.sex}\n身份证:{self.id_card}')

创建对象

python 复制代码 
对象名 = 类名()
python 复制代码 
"""
一：实例（创建对象）
对象名 = 类名()
"""
gqq = Person("启强", "男", 610000000000000001)
gqq.print_person_info()

"""
二、修改对象属性、获取对象属性
1. 通过修改对象属性可以将已有的属性值修改
2. 类外面可通过 "对象名.属性名" 获取对象属性
"""
gqq.name = "划水老师傅"
gqq.sex = "男"
gqq.id_card = 100861000000000002
print(gqq.name)
print(gqq.sex)
print(gqq.id_card)

"""
三：通过类方法，获取对象属性
"""
gqq.print_person_info()

"""
四：__str__测试
"""
print(gqq)

一个类中，可以实例化多个对象。

python 复制代码 
gqq = Person("启强", "男", 610000000000000001)
gqq.print_person_info()
lsf = Person("老师傅","男",610000000000000002)
lsf.print_person_info()
"""run:
姓名：启强
性别：男
身份证:610000000000000001
姓名：老师傅
性别：男
身份证:610000000000000002
"""

类里面self的含义

之前的代码，大家应该能看到类中的方法形参中，第一个参数是"self"，这是指的是调用该函数的对象。

练习题-烤地瓜

python 复制代码 
"""
需求名称：烤地瓜
需求描述：
一、地瓜被烤时间对应地瓜状态
    1.0-3分钟：生的地瓜。
    2.3-5分钟：半生不熟的地瓜。
    3.5-8分钟：地瓜是熟的。
    4.超过8分钟：地瓜被烤糊了。
二、用户可以按照自己意愿添加调料。
"""

"""
需求实现步骤分析：
一、地瓜的属性
    1.被烤的时间
    2.地瓜的状态
    3.添加的调料
二、地瓜的方法
    1.被烤
        a.用户根据自己意愿设定每次烤地瓜的时间。
        b.判断地瓜被烤的总时间是在哪个区间，修改地瓜状态。
    2.添加调料
        a.用户根据意愿设定添加的调料。
        b.将用户添加的调料存储。
三、显示对象信息
"""


class SweetPotato:
    """
    定义类：
    1.类初始化
    2.定义类方法"被烤"、"添加调料"
    3.显示对象信息__str__方法
    """

    def __init__(self):
        # 被烤时间，初始化为0
        self.cook_time = 0
        # 被烤状态
        self.cook_state = "生的"
        # 调料列表
        self.condiments = []

    def cook(self, time):
        """
        根据烤地瓜的时间判断地瓜状态
        :param time: 地瓜被烤时间
        :return:None
        """
        # 模拟用户烤地瓜时可以随时查看烤了多久，所以需要将已烤时间进行累加计算
        self.cook_time += time
        # 用累加的整体时间判断地瓜目前状态
        if 0 <= self.cook_time < 3:
            # 根据时间修改类属性
            self.cook_state = "生的"
        elif 3 <= self.cook_time < 5:
            self.cook_state = "半生不熟"
        elif 5 <= self.cook_time < 8:
            self.cook_state = "熟了"
        elif self.cook_time >= 8:
            self.cook_state = "烤糊了"

    def add_condiments(self, condiment):
        """
        用户根据自己意愿，任意添加调料
        :param condiment: 调料名称
        :return:
        """
        self.condiments.append(condiment)

    def __str__(self):
        """
        :return:返回地瓜被烤时间及状态
        """
        return f"这个地瓜烤了{self.cook_time}分钟，状态是{self.cook_state}，调料有{self.condiments}"


if __name__ == '__main__':
    """
    测试类
    """
    my_potato = SweetPotato()
    print(my_potato)
    my_potato.cook(2)
    my_potato.add_condiments("椒盐")
    print(my_potato)

练习题-搬家具

python 复制代码 
"""
需求名称：搬家具
需求描述：
一、将小于房间剩余面积的家具摆放在房子中
二、用户可以按照自己意愿添加调料。
"""

"""
需求实现步骤分析：
一、定义类
    1.房子类
        实例属性：
            a.房子地理位置。
            b.房子占地面积。
            c.房子剩余面积。
            d.房子内家具列表
        实例方法：
            容纳家具
        显示房屋信息
    2.家具类
        实例属性：
            a.家具名称
            b.家具占地面积
"""


class Furniture:
    """
    定义类：家具类
    """

    def __init__(self, name, area):
        # 家具名字
        self.name = name
        # 家具占地面积
        self.area = area


class Home:
    """
    定义类：房子类
    """

    def __init__(self, address, area):
        # 地理位置
        self.address = address
        # 房屋面积
        self.area = area
        # 剩余面积
        self.free_area = area
        # 家具列表
        self.furniture = []

    def __str__(self):
        return f'房子地址：{self.address}，占地面积{self.area}，剩余面积{self.free_area}，家具有{self.furniture}'

    def add_furniture(self, item):
        """
        容纳家具
        """
        if self.free_area >= item.area:
            self.furniture.append(item.name)
            # 家具搬入后，房屋剩余面积 = 之前剩余面积 - 该家具面积
            self.free_area -= item.area
        else:
            print("家具占地面积超过剩余面积。")


if __name__ == '__main__':
    bad = Furniture("双人床", 6)
    sofa = Furniture("沙发", 13)
    my_home = Home("西安曲江", 200)
    my_home.add_furniture(bad)
    my_home.add_furniture(sofa)
    print(my_home)
"""run:
房子地址：西安曲江，占地面积200，剩余面积181，家具有['双人床', '沙发']
"""

更新中...

相关推荐
熬夜学编程的小王5 分钟前
【C++篇】深度解析 C++ List 容器：底层设计与实现揭秘
开发语言·数据结构·c++·stl·list
GIS 数据栈6 分钟前
每日一书 《基于ArcGIS的Python编程秘笈》
开发语言·python·arcgis
Mr.139 分钟前
什么是 C++ 中的初始化列表？它的作用是什么？初始化列表和在构造函数体内赋值有什么区别？
开发语言·c++
爱分享的码瑞哥10 分钟前
Python爬虫中的IP封禁问题及其解决方案
爬虫·python·tcp/ip
猫爪笔记11 分钟前
前端：HTML （学习笔记）【2】
前端·笔记·学习·html
_不会dp不改名_15 分钟前
HCIA笔记3--TCP-UDP-交换机工作原理
笔记·tcp/ip·udp
陌小呆^O^21 分钟前
Cmakelist.txt之win-c-udp-server
c语言·开发语言·udp
Gu Gu Study28 分钟前
枚举与lambda表达式，枚举实现单例模式为什么是安全的，lambda表达式与函数式接口的小九九~
java·开发语言
时光の尘43 分钟前
C语言菜鸟入门·关键字·float以及double的用法
运维·服务器·c语言·开发语言·stm32·单片机·c
-一杯为品-1 小时前
【51单片机】程序实验5&6.独立按键-矩阵按键
c语言·笔记·学习·51单片机·硬件工程
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作