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

文章目录

  • 前言:这一篇文章,包含了 Python 所有的基础语法知识。
  • 一、Python命名规范
  • 二、Python变量
    • 变量的作用
    • 定义变量
    • 变量引用
    • 交换变量的值
  • 三、Python数据类型
    • 字符串
      • 根据下标获取字符串中某个字符
      • 字符串的运算
      • 查找 find
      • 查找 index
      • 统计 count()
      • 判断 isalnum、isalpha、isdigit....
      • 修改 replace
      • 分割 split
      • 切片 通过下标
      • 合并 join
      • 转换大小写 capitalize、lower、swapcase、title、upper
    • 列表
      • 根据下标查找列表元素
      • 查找 index()
      • 统计 count()
      • 长度 len()
      • 判断是否存在 in
      • 判断是否存在 not in
      • 删除 del()
      • 删除 pop()
      • 删除 remove()
      • 删除 clear()
      • 增加 append()
      • 增加 extend()
      • 增加 insert()
      • 修改指定下标数据
      • 逆置数据 reverse()
      • 排序 sort()
      • 复制 copy()
      • 遍历 while & for
      • 列表嵌套
      • 练习题
    • 元组
      • 根据下标查找列表元素
      • 查找 index()
      • 统计 count()
      • 长度 len()
      • 修改
    • 字典
      • 增加
      • 删除 del()
      • 清空 clear()
      • 修改
      • 查找 通过字典 key
      • 查找 get()
      • 查找 keys()
      • 查找 values()
      • 查找 items()
      • 遍历
    • 集合
      • 创建集合
      • 追加 add()
      • 追加 update()
      • 删除 remove()
      • 删除 discard()
      • 删除 pop()
      • 查找 in,not in
    • 数据类型转换
    • 数据的可变类型和不可变类型
    • 数据拆包
  • 四、print 输出
    • 格式化输出
    • 转义字符“\”
    • 结束符
  • 五、运算符
    • 算数运算符
    • 赋值运算符
    • 复合赋值运算符
    • 比较运算符
    • 逻辑运算符
      • if
      • if.....else
      • if....elif.....else
      • if 嵌套
      • 三目运算符
      • while循环
      • for 循环
  • 六、推导式
    • 列表推导式
    • 字典推导式
    • 集合推导式
  • 七、函数
    • 函数的作用
    • 函数的参数
      • 位置参数
      • 关键字参数
      • 缺省参数
      • 不定长参数-位置参数
      • 不定长参数-关键字参数
    • 函数的返回值
    • 函数的说明文档
    • 函数嵌套
    • 变量的作用域与函数的关系
      • 局部变量
      • 全局变量
    • 多函数程序执行流程
    • 函数练习题-1
    • 递归
    • lambda表达式
    • 高阶函数
      • 内置高阶函数:Map()
      • 内置高阶函数:reduce()
      • 内置高阶函数:filter()
  • 八、文件操作
    • 文件操作的作用
    • 文件的基本操作
    • 文件的创建和写入
    • 文件的读取
    • 文件指针操作seek()
    • 练习题-备份文件
    • 文件和文件夹的操作
  • 九、面向对象
    • 面向对象基础知识
      • 定义类
      • 创建对象
      • 类里面self的含义
      • 练习题-烤地瓜
      • 练习题-搬家具

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

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

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

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

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

我建议初学者:

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

一、Python命名规范

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

二、Python变量

变量的作用

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

定义变量

# 变量名 = 值
name = "测试划水老师傅"

变量引用

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

注:print() 函数在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
"""

交换变量的值

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中的数据类型:

数值:
	- 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}

字符串

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)}")

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

str_abc = 'abc'
print(f"str_abc:获取{str_abc}字符串的第1个字符是:{str_abc[0]}")

字符串的运算

print("抖音" + "测试划水老师傅!")
print("测试划水老师傅!" * 3)

查找 find

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

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

查找 index

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

"""
语法:
字符串序列.index(旧子串,新子串,替换次数)
"""
str = "My name is Python."
print(str.index("name"))

统计 count()

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

"""
语法:
字符串序列.count(子串)
"""
str = "My name is Python."
print(str.count("n"))

判断 isalnum、isalpha、isdigit…

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

"""
语法:
字符串序列.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():按照指定字符分割字符串

"""
语法:
字符串序列.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.']

"""

切片 通过下标

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

合并 join

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

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

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

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

# 注意: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()}")

列表

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

根据下标查找列表元素

name_list = ["Kevin","Tom","Jack"]
print(name_list[0])
print(name_list[1])
print(name_list[2])

"""
Kevin
Tom
Jack
"""

查找 index()

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

"""
语法:列表序列.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 
    print(name_list.index('Kevin_1111'))
ValueError: 'Kevin_1111' is not in list
"""

统计 count()

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

name_list = ["Kevin","Tom","Jack"]
print(name_list.count("Kevin"))
print(name_list.count("kevin"))
print(name_list.count("Bob"))

"""
1
0
0
"""

长度 len()

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

name_list = ["Kevin","Tom","Jack"]
print(len(name_list))

"""
3
"""

判断是否存在 in

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

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

"""
True
False
"""
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

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

"""
False
True
"""

删除 del()

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

"""
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 
    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()

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

"""
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()

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

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

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

删除 clear()

清空列表

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

"""run:
[]
"""

增加 append()

列表结尾追加数据

"""
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()

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

"""
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()

指定位置新增数据

"""
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
"""

修改指定下标数据

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

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

逆置数据 reverse()

"""
2.逆序 reverse()
"""
id = [1,2,4,4,5,1]
id.reverse()
print(id)

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

排序 sort()

"""
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()

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

"""
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

"""
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
"""

列表嵌套

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

"""run:
['测试划水老师傅', 'Python', 'Java']
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

元组

t = (数据1,数据2,数据3.....)
  1. 元组可以存储多个数据
  2. 数据不能被修改
  3. 元组写法 t1=(10,)即如果只有一组数据,也需要在末尾添加“,”,多个数据写法:t2=(10,20)

根据下标查找列表元素

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

查找 index()

"""
2. index()
"""
print(t1.index("Python"))

统计 count()

"""
3. count()
"""
print(t1.count("Python"))

长度 len()

""
4. len()
"""
print(len(t1))

修改

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

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'])
"""

字典

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

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

增加

字典序列[key] = 值

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

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

删除 del()

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

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


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

清空 clear()

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

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

修改

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

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

查找 通过字典 key

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

查找 get()

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

查找 keys()

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

查找 values()

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

查找 items()

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

遍历

  • 遍历字典的key
  • 遍历字典的value
  • 遍历字典的元素
  • 遍历字典的键值对(拆包)
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(),因为{} 是用来创建字典的。

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'}


"""

追加 add()

add(),用来增加一个单一数据。
集合具有去重功能,所以,当向集合追加的数据已存在,则不进行任何操作。

s1 = {10, 20, 30, 40}
s1.add(15)
s1.add(10)
print(s1)
"""run:
{40, 10, 15, 20, 30}
"""

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

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

追加 update()

追加的数据是序列。

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

非序列数据,会报错

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

删除 remove()

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

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 
    s1.remove(60)
KeyError: 60
{40, 20, 30}
"""

删除 discard()

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

s1 = {10, 20, 30, 40}
s1.discard(10)
print(s1)
s1.discard(60)
print(s1)
"""run:
{40, 20, 30}
{40, 20, 30}
"""

删除 pop()

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

s1 = {10, 20, 30, 40}
s1.pop()
print(s1)
"""run:
{10, 20, 30}
"""

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

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 
    s1.pop()
KeyError: 'pop from an empty set'
"""

查找 in,not in

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

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

数据类型转换

"""
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,输入的类型是
类型转换1234:
类型转换1234.0:
类型转换1234:
类型转换1234:
类型转换('1', '2', '3', '4'):
类型转换['1', '2', '3', '4']:
"""

# 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]:
"""

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

  1. 可变的:列表、集合、字典(可以进行更改,并且更改后物理地址不会发生改变)
  2. 不可变的:数字(整型、浮点数)、字符串、元组(不可以进行更改,更改后就是一个新的对象了,物理地址发生了变化)
# 列表 可变类型,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
"""
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
"""

数据拆包

元组拆包

def return_str():
    return "测试划水老师傅", "30岁"

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

字典拆包

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 输出

格式化输出

"""
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))

转义字符“\”

# 换行符 \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")

结束符

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 | 元素是否不存在 | 字符串、列表、元组、字典 |

赋值运算符

运算符 描述 实例
= 赋值 将=右侧的结果赋值给符号左侧的变量
# 单个变量赋值
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

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

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

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

if…else

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

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

if…elif…else

"""
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 嵌套

"""
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:
您是否有钱坐公交?[是/否]是
您有钱,可以坐公交!
公交车是否有空座?[是/否]是
公交车上有座位,您可以坐在座位上!
"""
"""
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("电脑获胜!")

三目运算符

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

while循环

"""
while循环初了解
"""
#循环5次我是Bob
i = 0
while i < 5:
    print("我是bob。")
    i += 1
"""
1-100的累加和
"""
i = 0
result = 0
while i <= 100:
    result += i
    i += 1
print(result)
"""
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 循环

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

六、推导式

列表推导式

作用:用一个表达式创建一个有规律的列表或控制一个有规律的列表
列表推导式又叫列表生成式。

# 快速创建一个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]
"""
# 多个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)

字典推导式

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

# 创建一个字典:字典的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统计数据少的列表数据个数则不会报错。
"""

提取字典中目标数据

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}
"""

集合推导式

快速创建一个集合

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

七、函数

函数的作用

函数就是将一段具有独立功能的代码块整合到一个整体并命名,在需要的位置调用这个名称即可完成对应的需求。
函数在开发过程中,可以更高效的实现代码重用。

# Step1:先定义函数
def print_hello():
    print("Hello")


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

函数的参数

"""
函数:固定计算 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
注意:传递和定义的参数的顺序及个数必须一致
:::

def user_info(name, age, sex):
    print(f"姓名:{name},年龄{age},性别{sex}")

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

关键字参数

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

def user_info(name, age, sex):
    print(f"姓名:{name},年龄{age},性别{sex}")

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

缺省参数

也叫默认参数,用于定义函数,为参数提供默认值,调用函数时,可以不传入该默认参数的值。
:::info
注意:所有位置参数必须卸载默认参数前,包括函数定义和调用
:::

def user_info(name, age, sex="男"):
    print(f"姓名:{name},年龄{age},性别{sex}")

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

不定长参数-位置参数

也叫可变参数。用于不确定调用时会会传入多少个参数(不传参数也可以)的场景。此时,用包裹(packing)位置的参数,或者包裹关键字参数,来进行参数传递,会显得非常方便。
:::info
注意:传进的所有参数都会被args变量收集,它会根据传进参数的位置合并为一个元组(tuple),args是元组类型,这就是包裹位置传递。
:::

def user_info(*args):
    print(args)

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

不定长参数-关键字参数

收集所有关键字参数,返回一个“字典”

def user_info(**kwargs):
    print(kwargs)

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

:::info
不定长参数“位置参数”、“关键字参数”,无论是包裹位置还是包裹关键字传递,都是一个组包的过程。
:::

函数的返回值

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

def shoopping():
    return "《Python核心编程》"

goods = shoopping()
print(goods)

return的特点:

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

返回值作为参数传递:

def test_A():
    str = "Python"
    return str

def test_B(book):
    print(book)

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

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

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')

('Python', 'Java')

['Python', 'Java']

{'key1': 'Python', 'key2': 'Java'}

Python、Java

"""

函数的说明文档

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

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

shoopping()
    这是一个介绍return的简单函数
    :return: "《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核心编程》"))

练习

def print_line():
    print("-" * 20)


print_line()


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

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

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

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

局部变量

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

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

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

全局变量

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

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

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

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

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

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

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

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

def testB():
    global a
    a = "Python"
    print(a)
testA()
testB()
print(f'全局变量a = {a}')
"""run:
测试划水老师傅
Python
全局变量a = 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. 调用函数
      :::
"""
需求:
进入系统显示系统功能页面,功能列表如下:
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

"""
利用递归实现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表达式能接收任何数量的参数,但只能返回一个表达式的值。
# 函数
def function_1():
    return 100
print(function_1)
print(function_1())

# lambda表达式写法
function_2 = lambda: 100
print(function_2)
print(function_2())
"""run:

100
 at 0x00000208FADD7AC0>
100
"""

携带参数写法

# 函数
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
"""

参数用法与函数一致

# 无参数
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'}
"""

判断写法

function_1 = lambda a, b: a if a > b else b
print(function_1(1, 2))
"""run:
2
"""

排序写法

# 按照列表字典中的某个值进行排序
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)

高阶函数

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

  • 化简代码,增加代码的灵活性。
  • 函数式编程大量使用函数,减少了代码的重复,因此程序比较短,开发速度较快。
# 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)返回。、

"""
计算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:

[1, 4, 9, 16]
"""

内置高阶函数:reduce()

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

"""
计算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()来转换。

"""
过滤获取列表中所有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:

['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+ 以二进制打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写

文件的创建和写入

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

文件的读取

"""
文件对象.read(num)
num 表示要从文件中读取的数据的长度(单位是字节),如果没有传入num,那么久表示读取文件中所有的数据
"""
file = open('测试划水老师傅.txt', 'r', encoding='utf-8')
read_result = file.read()
print(read_result)
file.close()
"""run:
张三
李四
王五
王麻子
"""
#访问字节数共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:
张三
李
"""
"""
文件对象.readlines()
可以按照行的方式把整个文件中的内容进行一次性读取,并且返回的是一个列表,其中每一行的数据为一个元素。
"""
file_readlines = open('测试划水老师傅.txt','r',encoding='utf-8')
readlines_result = file_readlines.readlines()
print(readlines_result)
file_readlines.close()
"""run:
['张三\n', '李四\n', '王五\n', '王麻子']
"""
"""
文件对象.readline()
一次读取一行的内容
"""
file_readline = open('测试划水老师傅.txt','r',encoding='utf-8')
readline_result = file_readline.readline()
print(readline_result)
file_readline.close()
"""run:
张三
"""

文件指针操作seek()

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

练习题-备份文件

"""
需求:用户输入当前目录下任意文件名称,程序完成对该文件的备份功能,备份名称为“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”详细学习

"""
1.导入模块 os
2.使用模块内功能,对文件及文件夹操作
"""
import os

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

# 创建文件夹
os.mkdir("Test")
# 删除文件夹
os.rmdir('Test')
import os

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

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

九、面向对象

面向对象基础知识

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

  • 特征——行为
  • 行为——方法

比如工厂在制造电脑时,需要用到的图纸,根据图纸制作出一台电脑。
图纸——>类
电脑——>对象,是类创建出来真实存在的事物。

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

定义类

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

class 类名():
    代码
    ......
"""
这是一个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}')

创建对象

对象名 = 类名()
"""
一:实例(创建对象)
对象名 = 类名()
"""
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)

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

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

类里面self的含义

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

练习题-烤地瓜

"""
需求名称:烤地瓜
需求描述:
一、地瓜被烤时间对应地瓜状态
    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)

练习题-搬家具

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

"""
需求实现步骤分析:
一、定义类
    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,家具有['双人床', '沙发']
"""

更新中…

你可能感兴趣的:(「Python」编程,python,学习,笔记,开发语言,pycharm,程序人生,改行学it)