一、字符串str内置方法

# 类型转换(把其他类型转换成自己的类型)
字符串可以转换所有类型的数据值,从结果看就是在两边加上引号

# 索引取值
information = 'hello python'
print(information[0])

# 切片操作
information = 'Hello World'
print(information[6:])  # 从6取到结尾
print(information[:6])  # 取到第六个就结束，第六个不取
print(information[:])  # 取所有的值
print(information[-1:])  # 从后往前取，从后往前取的时候
print(information[-5:-1])  # 用负的位置坐标取值，需要小的在前大的在后
print(information[6:10])  # 从第六个开始，取到10，但是取不到10的位置，只能到九
print(information[6:10:2])  # 从第六个开始，取到10，但是取不到10的位置，并且两个字符取一次
print(information[10:6:-1])  # 从第10个开始，取到6，但是取不到6的位置，是从后往前取

# 计算长度的len
information = 'hello world'
print(len(information))

# 删除字符串首尾的空格strip
information = '  hello world  '
print(information.strip())
# 左侧：lstrip
information = '  hello world  '
print(len(information))
print(information.lstrip())
print(len(information.lstrip()))
# 右侧：rstrip
information = '  hello world  '
print(information.rstrip())
print(len(information.rstrip()))

# 删除指定的字符并从删除的位置把字符串变成列表中的一个个值split
information = 'hello world'
print(information.split(' '))
# 这里我们可以看到根据中间的空格把字符串分成了含有两个值的列表，并且空格被删掉了

# format方法：格式化输出
# format玩法1:等价于占位符
# res = 'my name is {} my age is {}'.format('jason', 123)
# print(res)
# format玩法2:索引取值并支持反复使用
# res = 'my name is {0} my age is {1} {0} {0} {1}'.format('jason', 123)
# print(res)
# format玩法3:占位符见名知意
# res = 'my name is {name1} my age is {age1} {name1} {age1} {name1} '.format(name1='jason', age1=123)
    # print(res)
    # format玩法4:推荐使用(******)
    name = input('username>>>:')
    age = input('age>>>:')
    res = f'my name is {name} my age is {age}'

# upper()把当前字符串中的字母全部转大写
 
# lower()把当前字符串中的字母全部转小写
 
# isupper()判断当前字符串中的字母是否全大写,返回True或者False
 
# islower()判断当前字符串中的字母是否全小写,返回True或者False
 
# startswith()判断字符串是否以括号内指定的字符开头,返回Ture或False
 
# endswith()判断字符串是以括号内指定字符结尾,返回True或False

# join()从可迭代对象中取出多个字符串,然后按照指定的分隔符进行拼接,拼接的结果为字符串
 
# replace()用新的字符替代字符串中旧的字符
 
# isdigit()判断字符串是否是纯数字

了解方法

# find()从指定范围内查找字符串的起始索引,找到则返回数字1,找不到则返回-1
 
# index()同find,但是找不到时会报错
 
# count()统计字符串在大字符串中出现的次数
 
# center()居中展示
 
# ljust()左对齐
 
# rjust()右对齐
 
# zfill()字符串右对齐,不够0填充
 
# title()每个单词的首字母大写
 
# captalize()首字母大写
 
# swapcase()大小写翻转

二、列表(list)内置方法

# 1.类型转换(把其他类型转换成自己的类型)能够被for循环的数据类型都可以转换列表
print(list(123))  不可
print(list(1.11)) 不可
print(list('hello')) # ['h', 'e', 'l', 'l', 'o']
print(list([11, 22, 33, 44])) # [11, 22, 33, 44]
print((list({'username':"kevin", "age":20})))  # ['username', 'age']
print(list((11, 22, 33, 44)))  # [11, 22, 33, 44]
print(list({11, 22, 33, 44}))  # [33, 11, 44, 22]

# 2. 列表的修改
my_friends = ['tony', 'jason', 'tom', 4, 5]
print(my_friends[0])
# 1. 修改值
my_friends[0] = 'jack'
print(my_friends)

# 3.增加值
# append()列表尾部追加元素
 
# insert()在指定位置插入元素
 
# extend()一次性在列表尾部添加多个元素 for循环加append
 
# 4.切片操作
my_friends = ['tony', 'jason', 'tom', 4, 5, 6, 7, 8]
print(my_friends[0:3])  # (顾头不顾尾，步长)
print(my_friends[0:5:2])  # (顾头不顾尾，步长)

5.统计列表的长度
# len()添加列表的长度(个数)

6.删除列表数据
# 通用删除关键字del

# remove()括号内指定要删除的数据

# pop()默认输出列表最后一个元素,并将输出的返回值,括号内可以通过加索引值

# reverse()颠倒列表内元素顺序
 
# sort()给列表内所有元素排序，参数reverse用来指定是否颠到排序,默认为False

三、可变类型与不可变类型

可变类型:列表 字典 集合
	值改变，内存地址不变
不可变类型:数字类型 字符串 元组
	值改变，内存地址也变

四、队列和堆栈

队列:先进来的先出去
堆栈:后进来的先出去

五、字典(dict)内置方法

# 1.定义：在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型，详见第八小节，通常key应该是str类型，因为str类型会对value有描述性的功能
info={'name':'tony','age':18,'sex':'male'} #本质info=dict({....})
# 也可以这么定义字典
info=dict(name='tony',age=18,sex='male') # info={'age': 18, 'sex': 'male', 'name': 'tony'}
 
# 2.类型转换
# 转换1: 
>>> info=dict([['name','tony'],('age',18)])
>>> info
{'age': 18, 'name': 'tony'}
 
# 转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
>>> {}.fromkeys(('name','age','sex'),None)  
{'age': None, 'sex': None, 'name': None}
 
# 3.按k取值(不推荐使用)
user_dict = {
    'username': 'jason',
    'password': 123,
    'hobby': ['read', 'music', 'run']
    }
print(user_dict['username'])	# jason
print(user_dict['phone'])  # k不存在会直接报错
 
# 4..按内置方法get取值(推荐使用)
print(user_dict.get('username'))  # jason
print(user_dict.get('age'))  # None
 
# 5.修改数据值
print(id(user_dict))
user_dict['username'] = 'tony' # 键存在则修改对应的值
print(id(user_dict))
print(user_dict)
 
# 6.新增键值对
user_dict['age'] = 18	# 键不存在则新增键值对
print(user_dict)
 
# 7.删除数据
del user_dict['username']
print(user_dict)
res = user_dict.pop('password')
print(user_dict)
print(res)	# 123
 
# 8.统计字典中键值对的个数
print(len(user_dict))
 
# 9.字典三剑客
print(user_dict.keys)	# 一次性获取字典所有的键
dict_keys(['username', 'password', 'hobby'])
print(user_dict.values())	# 一次性获取字典所有的值
dict_values(['jason', 123, ['read', 'music', 'run']])
print(user_dict.items())	# 一次性获取字典的键值对数据
dict_items([('username', 'jason'), ('hobby', ['read', 'music', 'run'])])
	for i in user_dict.items():
	k,v = i
	print(k,v)
 
# 补充说明
print(dict.fromkeys(['name', 'pwd', 'hobby'], 123))	# 快速生成值相同的字典
res = (dict.fromkeys(['name', 'pwd', 'hobby'], 123))	# 快速生成值相同的字典
res = user_dict.setdefault('username', 'tony')
print(user_dict, res)	# 键存在则不修改 结果是键对应的值
res = user_dict.setdefault('age', 123)
print(user_dict, res)
# 存不存在则新增键值对 结果是新增的值
user_dict.popitem()	# 弹出键值对 后进先出
user_dict.update({'username': 'jack', 'age': 20})
# key存在则修改,不存在则新增

六、元组(tuple)内置方法

定义：t1 = (11,22,33,44)
# 数据类型转变
# 但凡能被for循环遍历的数据类型都可以传tuple()转换成元组类型
print(tuple(123))
print(tuple(123.11))
print(tuple('hello'))	# ('h', 'e', 'l', 'l', 'o')
print(tuple([11,22,33,44]))	# (11,22,33,44)
print(tuple((1,2,3,4)))	# (1,2,3,4)
print(tuple({'username': 'kevin', 'age': 19}))	# ('username', 'age')
print(tuple({111,222,33,444}))	# (33, 444,222,111)
 
# 取值
print(tuple1[0])
print(tuplel[3])
 
print(tuplel[-1])
print(tuplel[-2])
print(tuplel[-3])
 
# 长度
len(tuplel)
 
'''元组笔试题'''
t = (111)
t1 = (111.11)
t2 = ('hello')
t3 = ('hello', )	# 当元组内部哪怕是一个元素,也要加逗号隔开,否则就不是元组类型
l = ['hello',]	# list
'''容器类型:可以存放多个元素的数据类型都是容器类型
推荐:如果是容器类型,内部就算有一个元素,也最后都加上一个逗号隔开
'''
print(type(t))	# <class 'int'>
print(type(t1))	# <class 'float'>
print(type(t2))	# <class 'str'>
print(type(t3))	# <class 'tuple'>
print(type(l))	# <class 'tuple'>

七、集合(set)内置方法

# 1.类型转换
	set()
	集合内数据必须是不可变类型(整型 浮点型 字符串 元组)
 	集合内数据也是无序的 没有索引的概念
# 2.集合需要掌握的方法
	去重
 	关系运算
	ps:只有遇到上述两种需求的时候才应该考虑使用集合
# 3.去重
	 s1 = {11, 22, 11, 22, 22, 11, 222, 11, 22, 33, 22}
 	 l1 = [11, 22, 33, 22, 11, 22, 33, 22, 11, 22, 33, 22]
    s1 = set(l1)
    l1 = list(s1)
    print(l1)
 	'''集合的去重无法保留原先数据的排列顺序'''
# 4.关系运算
	群体之间做差异化校验
 	eg: 两个微信账户之间 有不同的好友 有相同的好友
 	 f1 = {'jason', 'tony', 'jerry', 'oscar'}  # 用户1的好友列表
    f2 = {'jack', 'jason', 'tom', 'tony'}  # 用户2的好友列表
    # 1.求两个人的共同好友
    # print(f1 & f2)  # {'jason', 'tony'}
    # 2.求用户1独有的好友
    # print(f1 - f2)  # {'jerry', 'oscar'}
    # 3.求两个人所有的好友
    # print(f1 | f2)  # {'jason', 'jack', 'tom', 'tony', 'oscar', 'jerry'}
    # 4.求两个人各自独有的好友
    # print(f1 ^ f2)  # {'oscar', 'tom', 'jack', 'jerry'}
    # 5.父集 子集
    print(f1 > f2)
    print(f1 < f2)

八、员工管理系统

all_info_dict = {}
while True:
    print("""
    1.添加员工信息
    2.查询特定员工
    3.修改员工薪资
    4.查询所有员工
    5.删除特定员工
    """)
    choice_num = input('请输入您想要选择的功能编号>>>:').strip()
    if choice_num == '1':
        while True:
            print('添加员工信息')
            number = input('请输入员工编号,输入(q)退出>>>:').strip()
            if number == 'q':
                break
            if not number.isdigit():
                print('编号必须是纯数字')
                continue
            if number in all_info_dict:
                print('员工编号已存在')
                continue
            else:
                username = input('请输入员工姓名>>>:').strip()
                staff_age = input('请输入员工年龄>>>:').strip()
                salary = input('请输入员工薪资>>>:').strip()
                data_dict = {}
                data_dict['num'] = number
                data_dict['name'] = username
                data_dict['age'] = staff_age
                data_dict['pay'] = salary
                all_info_dict[number] = data_dict
                print(f'员工{username}添加成功')

    elif choice_num == '2':
        while True:
            print('查询特定员工')
            number = input('请输入员工编号,输入(q)退出>>>:').strip()
            if number == 'q':
                break
            if not number.isdigit():
                print('编号必须是纯数字')
                continue
            if number in all_info_dict:
                data_dict = all_info_dict.get(number)
                print(f"""
                %%%%%%%% user info {data_dict.get('name')} %%%%%%%%
                编号:{data_dict.get('num')}
                姓名:{data_dict.get('name')}
                年龄:{data_dict.get('age')}
                薪资:{data_dict.get('pay')}
                %%%%%%%%%%%%%%%%%%%%%%%%%%%%
                """)
            else:
                print('该编号不存在')
    elif choice_num == '3':
        while True:
            print('修改员工薪资')
            number = input('请输入想要修改薪资的员工编号,输入(q)退出>>>:').strip()
            if number == 'q':
                break
            if not number.isdigit():
                print('编号必须是纯数字')
                continue
            if number in all_info_dict:
                amend_pay = input('请输入您想要修改的薪资>>>:').strip()
                data_dict = all_info_dict.get(number)
                data_dict['pay'] = amend_pay
                print(f'编号为{number}的员工薪资修改成功')
            else:
                print('编号不存在')
                continue
    elif choice_num == '4':
        print('查询所有员工')
        for data_dict in all_info_dict.values():
            print(f"""
            $$$$$$$$ user info {data_dict.get('name')} $$$$$$
            编号:{data_dict.get('num')}
            姓名:{data_dict.get('name')}
            年龄:{data_dict.get('age')}
            薪资:{data_dict.get('pay')}
            $$$$$$$$$$$$$$$$$$$$$$$$$$$
            """)
        else:
            print('暂无员工')
    elif choice_num == '5':
        while True:
            print('删除特定员工')
            number = input('请输入您想要删除的员工编号,输入(q)退出>>>:').strip()
            if number == 'q':
                break
            if not number.isdigit():
                print('编号必须是纯数字')
                continue
            if number in all_info_dict:
                all_info_dict.pop(number)
                print(f'编号为{number}的员工删除成功')
            else:
                print('员工编号不存在')
    else:
        print('暂无该功能编号')

九、字符编码

概念

• 我们在计算机中经常见到的文字、数字、英文字母、图片、视频、音频等，这些信息在计算机中都是以二进制的形式存储的，因为内存条是电子元器件组成的，它们只有高电平低电平两种状态，即0和1两个值,这个翻译本叫做字符编码表

字符编码的发展史

# 1.一家独大
	计算机是由美国人发明的 为了能够让计算机识别英文
	需要发明一个数字跟英文字母的对应关系
	ASCII码:记录了英文字母跟数字的对应关系
	用8bit(1字节)来表示一个英文字符
 
# 2.群雄割据
	中国人
		GBK码:记录了英文、中文与数字的对应关系
 		用至少16bit(2字节)来表示一个中文字符
		很多生僻字还需要使用更多的字节
		英文还是用8bit(1字节)来表示
	日本人
		shift_JIS码:记录了英文、日文与数字的对应关系
	韩国人
		Euc_kr码:记录了英文、韩文与数字的对应关系
"""
每个国家的计算机使用的都是自己定制的编码本
不同国家的文本数据无法直接交互 会出现"乱码"
"""
# 3.天下一统
	unicode万国码
	兼容所有国家语言字符
	起步就是两个字节来表示字符 
# utf系列:utf8 utf16 utf32...
	专门用于优化unocide存储问题
	英文还是采用一个字节 中文三个字节

字符编码的使用

# 1. 如何解决乱码问题？
	文本文件使用什么字符编码保存，打开的时候就要使用对应的字符编码
# 2. python解释器版本不同带来的差异
	# python2 解释器使用的字符编码还是ASCII表
	# python3 使用的是utf8编码
# 3. 添加文件模板
	settings
    	Editor
        	File and code template
            	python script
# 4. 编码与解码(核心)
	# 编码：
		将人类能够读懂的语言转为计算机能够读懂的语言
 
# bytes 字节，看成是二进制
	s1 = ss.encode('utf8')
	print(s1, type(s1)) # b'\xb3\xc3\xc4\xea\xc7\xe1\xa3\xac\xd1\xa7\xbc\xbc\xc4\xdc\xa3\xac\xd1\xf8\xbb\xee\xd7\xd4\xbc\xba'
	# 解码：
		将计算机能够读懂的语言转为人类能够读懂的语言
	print(s1.decode('utf8'))
	s = b'kevin123' # 只有英文字符和数字，要想编码的话，直接使用前缀b
	print(s.encode('utf8'))

十、文件操作

概念讲解

• 首先我们要知道文件是操作系统暴露给用户的快捷方式，当我们使用的时候只需要双击就能将文件读取到内存中运行，使用ctrl+s就可以将文件保存到硬盘中，这些对文件进行修改或使用的动作就是文件操作，除了借助操作系统，我们可以使用python代码进行这一系列的操作
  打开文件的两种方式

# 方式一:
	f=open(文件路径,文件读写模式,encoding='文件编码类型（默认情况下为utf8）')
	f.close()
"""
特点：一次只能打开一个文件，使用完文件后需要输入f.close关闭文件，但是如果忘记关闭文件并不会有提示
"""
 
# 方法二：
	with open(文件路径,文件读写模式,encoding='文件编码类型（默认情况下为utf8）') as f1,open(文件路径,文件读写模式,encoding='文件编码类型（默认情况下为utf8）') as f2:
	with条件下的操作代码
"""
特点：当我们使用with方法打开文件的时候，可以一次性打开多个文件并且不需要输入close方法，会自动运行close方法
"""
# 文件的类型：txt word excel py
 
 # 1. 打开文件
# open('文件路径', 'r', '字符编码')
 
f=open('a.txt', 'r', encoding='utf-8')
# print(f)  # <_io.TextIOWrapper name='a.txt' mode='r' encoding='utf8'>  文件句柄
print(f.read())
f.close()  # 关闭文件
 
"""
	语法格式：
		open('文件路径', '读写模式', '字符编码')
"""
 
# r的作用
'''当路径中可能存在有转移的字符时，字符串前面加上r来解决转义的问题'''
r'D:\python25\day09\a.txt'

文件的读写模式

1. r  >>> read: 只读 # 只能读，不能写
2. w  >>> write：只写 # 只能写，不能读
3. a  >>> append: 追加
# 读写模式
# 1. r
# 路径不存在，直接报错
# with open(r'a.txt', 'r', encoding='utf-8') as f:
#     print(f.read())
 
 
# 2. w
# 如果路径不存在，会新建一个文件出来
# with open('b.txt', 'w', encoding='utf-8') as f:
#     pass
 
# 1. 会先清空文件中得内容 2. 在进行写内容
'''写文件的是一定要小心，它会清空文件的'''
with open('a.txt', 'w', encoding='utf-8') as f:
    f.write('oldboy\n')
    f.write('oldboy\n')
    f.write('oldboy\n')
    f.write('oldboy\n')
    f.write('oldboy\n')
 
# a:追加模式
# 路径不存在的时候，也会新建一个文件出来
# with open('a.txt', 'a', encoding='utf-8') as f:
#     f.write('oldgirl\n')

文件的操作方法

# 读方法
	with open(r'a.txt', 'r', encoding='utf-8') as f:
		# print(f.read())  # 一次性读取文件内所有的数据
		# print(f.read())  # 一次性读取文件内所有的数据
		# print(f.read())  # 一次性读取文件内所有的数据
		# data = f.read()
	'''
	一次性读取文件所有的数据就会存在漏洞：导致内存溢出
	'''
		# print(f.readline())  # 一次读取一行
		# print(f.readline())  # 一次读取一行
		# print(f.readline())  # 一次读取一行
		# print(f.readable())  # True

	'''
	一次性读取所有的文件内容，并把他们以一行为一个数据值分开，放入列表中，注意末尾的换行符
	'''
		# print(f.readlines())  #  ['你好\n', '你好\n', '你好\n']

# 写方法
	with open('a.txt', 'w', encoding='utf-8') as f:
		# f.write('hello\n')
		# f.write('hello\n')
		# f.write('hello\n')
	"""
	用于判断文件是否可以写入
	"""
		# print(f.writable()) # True
	"""
	用于判断文件是否可以读取
	"""
		# print(f.readable())  # False
	"""
	在括号内可以插入一个列表，之后会将列表中的数据值一个个都写入到文本中
	"""
		# print(f.writelines(['你好1\n', '你好2\n', '你好3\n']))

文件操作方法补充

• 把文件中的所有内容一次性读取出来，括号内可以加入参数控制一次读取多少数据值，但是在不同的操作模式下有不同的读取规律。当文件过大的时候容易出现内存溢出的情况，因此有了以下读取方式：

for line in document:
 
print(line)
 
# 通过for循环一行行读取内容，防止出现内存溢出的情况

with open('a.txt', 'w', encoding='utf8') as f:
    f.write('hello')
    f.flush()
# 把内存中得数据立刻刷到硬盘中

文件的操作模式

• 上文中我们讲解的文本的读写模式只是操作模式中的一种，也是默认的操作模式，在输入读写模式的时候只需要简写就可以。这里我们还要介绍通用的操作模式——二进制模式。为了方便理解我们把t模式（文本操作模式）和b模式（二进制操作模式）

# 文件二进制读操作
	with open('a.txt', 'rb') as f:
		print(f.read(3).decode('utf-8'))

	"""
		1. r模式
			read()里面的数字代表的是一个字符
		2. b模式
			read()里面的数字代表的是一个字节
	"""

# 文件的移动光标(了解)
	with open('a.txt', 'rb') as f:
		print(f.read(12).decode('utf-8'))
		# f.seek(3,0)  # 控制指针的移动
		# f.seek(3,1)  # 控制指针的移动
		f.seek(-3,1)  # 控制指针的移动
		print(f.read().decode('utf-8'))
	"""
		f.seek总共有3种模式
			1. offset参数
				偏移量，移动的位置
				如果是整数，从左往右读取
				如果是负数，从右往左读取
			2. whence参数
				# 0: 默认的模式,该模式代表指针移动的字节数是以文件开头为参照的
				# 1: 该模式代表指针移动的字节数是以当前所在的位置为参照的
				# 2: 该模式代表指针移动的字节数是以文件末尾的位置为参照的
	"""

# 文件的修改(了解)
方式一：
	# 1. 读取b.txt文件数据
	with open('b.txt', 'r', encoding='utf-8') as f:
		data = f.read()
	print(data)  # kevin kevin kevin kevin say hello world
	new_data = data.replace('kevin', 'jack')

	# 2. 把新的数据再次写入文件
	with open('b.txt', 'w', encoding='utf-8') as  f1:
		f1.write(new_data)
方式二：
	# 修改文件内容的方式2:换地写
	'''先在另外一个地方写入内容 然后将源文件删除 将新文件命名成源文件'''
	import os
	# 调用了一个名叫os的方法库，方便后续使用内置方法操作

	with open('a.txt', 'r', encoding='utf8') as read_f, open('.a.txt.swap', 'w', encoding='utf-8') as write_f:
		for line in read_f:
			write_f.write(line.replace('tony', 'kevinSB'))
			# 从文件中读取内容然后遍历进行对比替换，并把替换后的内容写入到另一个文件中，最后我们会在另一个文件中得到修改后的结果

	os.remove('a.txt')  # 删除原来的文件
	os.rename('.a.txt.swap', 'a.txt')  # 把另一个文件命名成原来文件的名字，就当作把他替换了

十一、支持多用户登录注册功能

# 创建一个文件路径
with open(r'a.txt', 'a', encoding='utf8') as f:
    pass
# 循环打印展示给用户选择
while True:
    print("""
    1.注册功能
    2.登录功能
    """)
    # 获取用户输入的编号
    choice_num = input('请输入您想要执行的功能编号>>>:').strip()
    # 判断用户输入的编号(分支结构)
    if choice_num == '1':
        # 获取用户名
        username = input('请输入您的用户名>>>:').strip()
        # 循环读取数据
        with open(r'a.txt', 'r', encoding='utf8') as f2:
            for data in f2:     # jason|123
                list_data = data.split('|')     # ['jason', '123\n']
                # 将用户名与列表作比较
                if list_data[0] == username:
                    print(f'用户名{username}已存在')
                    break
            else:
                # 获取密码
                password = input('请输入您的密码>>>:').strip()
                # 使用尾部追加模式,记得加\n换行
                with open(r'a.txt', 'a', encoding='utf8') as f1:
                    f1.write(f'{username}|{password}\n')
                    print('注册成功')
    elif choice_num == '2':
        #  获取用户名和密码
        username = input('请输入您的用户名>>>:').strip()
        password = input('请输入您的密码>>>:').strip()
        # 循环将数据读出来
        with open(r'a.txt', 'r', encoding='utf8') as f:
            for data in f:      # kevin|321
                list_data = data.split('|')     # ['kevin', '321\n']
                # 将用户名和密码跟列表进行比较,想要去除\n
                if list_data[0] == username and password == list_data[1].strip('\n'):
                    print('登录成功')
                    break
            else:
                print('用户名或密码错误')

十二、函数前戏

• 当我们在编写代码实现功能的时候，比如验证用户的登陆状态（确认用户的用户名和密码），一些情况下需要反复验证，这种时候就会反复套用一段一样的代码来检验。仔细想想这些地方其实进行了重复操作，因此我们引入了函数进行简化。这就相当于一个工人去干活，在最初的时候需要一次次的制造工具再去干活，后来他发现这挺蠢的。就做了工具之后保存好，每次干活的时候拿出来使用一下就可以快速完成工作了

代码重复性比较多

代码兼容性不好

自己写的这个函数没有返回值(就是函数执行之后，没有返回结果)

函数:类似于工具，提前准备好，方便后续使用

十三、函数的语法结构

def 函数名(参数（可以有多个，后续会讲）:
	'''函数注释（解释函数功能）'''
	函数体代码
	return 返回值

# 1.def
	定义函数的关键字
# 2.函数名
	相当于变量名,命名遵循变量的命名规范,做到见名知意
# 3.参数
	可有可无,主要是在使用函数的时候规定要不要外界传数据进来
# 4.函数注释
	主要写一些函数功能的介绍，和一些参数的解释
# 5.函数体代码
	是整个函数的核心,主要取决于程序员的编写
# 6.return(返回值)
	使用函数之后可以返回给使用者的数据，可有可无
	当我们给返回值的时候可以写多个，甚至是不同数据类型的多个数据值，他们会被封装到一个元组中一次性输出
	当我们使用return的时候，意味着函数运行到这里就停止了，如果下方还有代码将不会运行

十四、函数的定义与调用

# 函数一共是两个阶段：定义，调用

1. 函数必须先定义，后调用
2. 函数在定义阶段，如果有参数，调用阶段也需要给对应的参数
3. 函数在定义阶段只检测语法是否正确，不执行具体的代码功能
4. 函数在调用阶段会执行具体的函数体代码
5. 如何调用函数？# 函数名加括号

函数的底层原理

1. 申请一块内存空间，存储函数体代码
2. 把函数体代码绑定给函数名
3. 通过调用函数(函数名())来执行函数体代码

十五、函数分类

# 1. 内置函数
	在python解释器中提前存在的，我们可以直接使用
   	eg:input, print,之前学习的数据类型的内置方法都是内置函数
# 2. 自定义函数
	# 我们自己写的函数
    2.1. 无参函数：定义函数的时候括号内没有参数
    2.2. 有参函数：定义函数的时候括号内写参数,调用函数的时候括号传参数
    2.3. 空函数：主要用于项目前期功能框架搭建
# 1.无参函数
# def my_len():
#     print(123)
# my_len()
 
# 2. 有参函数
def my_len(a,b):
    print('hello')
    print(a,b)
# my_len(1,2)
my_len('a','b')
 
# 3. 空函数
def my_func():
    # 1. 注册
    pass
    ...
 
def login():
    # 2.登录功能
    pass
 
def chongqian():
    # 3.这里是充值的逻辑
    pass

十六、函数的返回值

1.什么是返回值
	调用函数之后返回给调用者的结果
2.如何获取返回值
	变量名 赋值符号 函数的调用
 	res = func()  # 先执行func函数 然后将返回值赋值给变量res
3.函数返回值的多种情况
	3.1.函数体代码中没有return关键字 默认返回None
 	3.2.函数体代码有return 如果后面没有写任何东西还是返回None
 	3.3.函数体代码有return 后面写什么就返回什么
 	3.4.函数体代码有return并且后面有多个数据值 则自动组织成元组返回
 	3.5.函数体代码遇到return会立刻结束