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

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

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

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

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

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

我建议初学者：

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

一、Python命名规范

1. 模块命名：模块尽量使用小写命名，首字母保持小写，尽量不要用下划线

from unittest import util

2. 类名：类名使用驼峰命名风格，首字母大写，私有类可用一个下划线开头。

class Student:
	pass

class _PrivateStudent:
	pass

3. 函数：函数名一律小写，如有多个单词，用下划线隔开。私有函数在函数前加一个下划线_。

def pay():
	pass
def wechat_pay():
	pass
def _private_pay():
	pass

4. 变量名：变量名尽量小写，如有多个单词，用下划线隔开。

name = "Kevin"
nick_name = "测试划水老师傅"

5. 常量：常量使用以下划线分隔的大写命名。

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:

内置高阶函数：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，家具有['双人床', '沙发']
"""

更新中…