文章目录
- [前言:这一篇文章,包含了 Python 所有的基础语法知识。](#前言:这一篇文章,包含了 Python 所有的基础语法知识。)
- 一、Python命名规范
- 二、Python变量
- 三、Python数据类型
-
- 字符串
-
- 根据下标获取字符串中某个字符
- 字符串的运算
- [查找 find](#查找 find)
- [查找 index](#查找 index)
- [统计 count()](#统计 count())
- [判断 isalnum、isalpha、isdigit....](#判断 isalnum、isalpha、isdigit....)
- [修改 replace](#修改 replace)
- [分割 split](#分割 split)
- [切片 通过下标](#切片 通过下标)
- [合并 join](#合并 join)
- [转换大小写 capitalize、lower、swapcase、title、upper](#转换大小写 capitalize、lower、swapcase、title、upper)
- 列表
-
- 根据下标查找列表元素
- [查找 index()](#查找 index())
- [统计 count()](#统计 count())
- [长度 len()](#长度 len())
- [判断是否存在 in](#判断是否存在 in)
- [判断是否存在 not in](#判断是否存在 not in)
- [删除 del()](#删除 del())
- [删除 pop()](#删除 pop())
- [删除 remove()](#删除 remove())
- [删除 clear()](#删除 clear())
- [增加 append()](#增加 append())
- [增加 extend()](#增加 extend())
- [增加 insert()](#增加 insert())
- 修改指定下标数据
- [逆置数据 reverse()](#逆置数据 reverse())
- [排序 sort()](#排序 sort())
- [复制 copy()](#复制 copy())
- [遍历 while & for](#遍历 while & for)
- 列表嵌套
- 练习题
- 元组
-
- 根据下标查找列表元素
- [查找 index()](#查找 index())
- [统计 count()](#统计 count())
- [长度 len()](#长度 len())
- 修改
- 字典
- 集合
-
- 创建集合
- [追加 add()](#追加 add())
- [追加 update()](#追加 update())
- [删除 remove()](#删除 remove())
- [删除 discard()](#删除 discard())
- [删除 pop()](#删除 pop())
- [查找 in,not in](#查找 in,not in)
- 数据类型转换
- 数据的可变类型和不可变类型
- 数据拆包
- [四、print 输出](#四、print 输出)
- 五、运算符
-
- 算数运算符
- 赋值运算符
- 复合赋值运算符
- 比较运算符
- 逻辑运算符
-
- if
- if.....else
- if....elif.....else
- [if 嵌套](#if 嵌套)
- 三目运算符
- while循环
- [for 循环](#for 循环)
- 六、推导式
- 七、函数
- 八、文件操作
- 九、面向对象
前言:这一篇文章,包含了 Python 所有的基础语法知识。
原本自己一直在自学Java,因为工作需要,从一个Java的菜鸟转到Python的学习。
个人认为:
不论从效率还是功能上,Python更适合软件测试人员的使用。
期间,零零碎碎的做一些笔记,包含了基础语法以及其他奇淫技巧工具等。
自己关于测试所有的笔记,慢慢整理在CSDN上,利人利己。
我建议初学者:
- 不要只看别人的文章,还要自己动手写写。
- 甭管在你看来多简单的代码,边写边思考,多换换思路和写法去尝试举一反三。
- 学习过程中,可以多"作"下,别怕报错,报错才是进步的开始!
一、Python命名规范
- 模块命名:模块尽量使用小写命名,首字母保持小写,尽量不要用下划线
python
from unittest import util
- 类名:类名使用驼峰命名风格,首字母大写,私有类可用一个下划线开头。
python
class Student:
pass
python
class _PrivateStudent:
pass
- 函数:函数名一律小写,如有多个单词,用下划线隔开。私有函数在函数前加一个下划线_。
python
def pay():
pass
def wechat_pay():
pass
def _private_pay():
pass
- 变量名:变量名尽量小写,如有多个单词,用下划线隔开。
python
name = "Kevin"
nick_name = "测试划水老师傅"
- 常量:常量使用以下划线分隔的大写命名。
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"等。
但在我自学这一篇内容时,我问自己:
"数据类型"是什么?
为什么编程中,要定义"数据类型"?
所以,你有没有想过类似这些问题?
我的结论:
- 无疑,这是创建这门语言作者,制定的一种规范。(尽管他参考的是已有语言,所以我们常说,编程语言是相同的)
- 规定了数据的存储范围。
- 规定了数据的操作方式。
- 这样的规范,提高了程序运行的可靠性 、效率。
当然,现在这些我没有办法去举一些例子告诉你,也许在你慢慢学习过程中,会逐步体验到"规范"的意义!
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.....]
- 列表可以一次性存储多个数据,且可以为不同数据类型,一般建议存储类型一致。
- 列表为可变数据,即修改后,原有数据会被修改。
根据下标查找列表元素
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.....)
- 元组可以存储多个数据
- 数据不能被修改
- 元组写法 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'>
"""
数据的可变类型和不可变类型
- 可变的:列表、集合、字典(可以进行更改,并且更改后物理地址不会发生改变)
- 不可变的:数字(整型、浮点数)、字符串、元组(不可以进行更改,更改后就是一个新的对象了,物理地址发生了变化)
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的特点:
- 返回函数结果。
- 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
需求:
进入系统显示系统功能页面,功能列表如下:
- 添加学员
- 删除学员
- 修改学员信息
- 查询学员信息
- 显示所有学员信息
- 退出系统
系统共6个功能,用户根据自己需求选取。
:::success
实现步骤解析
- 显示功能界面
- 用户输入"功能序号"。
- 根据用户输入的功能序号,执行不同的业务(函数)。
- 定义函数
- 调用函数
:::
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("输入错误请重新输入!")
递归
递归属于一种编程思想。
递归的应用场景:
- 日常开发中,如果要遍历一个文件夹下所有文件,通常会使用递归来实现。
- 算法中,很多都离不开递归,例如"快速排序"。
- 爬虫程序中,经常用到递归思想。
递归的特点:
- 函数内部自己调用自己。
- 必须有出口。(没有出口,可能会形成死循环或者报错提示"超出最大递归深度"!)
[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,家具有['双人床', '沙发']
"""
更新中...