文章目录
七、函数基础
函数 是把 具有独立功能的代码块 组织为一个小模块，在需要的时候调用。在开发程序时，使用函数可以提高编写的效率和代码的重用率。
函数的使用包含两个步骤：
1、定义函数——封装 独立的功能
2、调用函数——享受 封装 的成果
体验：
将之前写过的 九九乘法表 用
def multiple_table():封装起来。
在这个python文件内部 调用函数的语法是： 模块名()
再新建一个python文件函数.py，编写程序：
import nine_nine# python文件名就是模块名
nine_nine.multiple_table()
在不包含函数的python文件中 调用函数的语法是：模块名.函数名()
运行之后就会看到九九乘法表。
1、函数的定义
格式：
def 函数名():
函数封装的代码
......
①def是英文define的缩写
②函数名称应该能够表达 函数封装代码 的功能，方便后续的调用。
③函数名称 的命名应该 符合标识符的命名规则，由字母、下划线、数字构成，不能以数字开头，不能与关键字重名。
注意：
定义好函数之后，只表示这个函数封装了一段代码而已。如果不主动调用函数，函数是不会主动执行的 。当程序执行时看到
def say_hello():时，只是知道这里定义了函数，但不会执行。只有当程序运行到say_hello()这行调用语句时，才会返回去执行函数。
不能在定义函数之前调用函数。因为必须在调用函数之前，保证python已经知道函数的存在。
因为函数比较独立，所以def上方应保留两个空行。
应用 ：
def say_hello():
"""
"多行注释"
打招呼
"""
print("你", end="")
print("好", end="")
print("呀", end="")
say_hello() # 如果没有这行调用，运行之后函数是没有输出的。
输出：
把光标放到 调用函数语句 处，点view→快速文档查看：
会弹出一个小窗口：
以上所有步骤可以用快捷键ctrl Q完成 。
ptcharm下方工具栏中：step into（快捷键F7）可以进入函数内部进行调试，step over（快捷键F8）会把函数作为一个整体进行调试。
应用：开发一个函数实现两个数字的求和：
def number_number(number1, number2): # 把number1, number2作为形参传递进来
"""
为两个数字求和
:return:number1, number2
"""
result = number1 + number2
print("%.02f + %.02f = %.02f" %(number1, number2, result))
return number1, number2
number_number(1, 2)
输出：
2、函数的返回值
return下方的语句不会被执行
应用：
def number_number(number1, number2):
"""
为两个数字求和
"""
return number1 + number2
print("这句会不会执行呢？")
print(number_number(1, 2))
显然，从输出结果可以看出，return后的语句是不会被执行的。
3、参数
从上述应用中可以看出，函数有了参数之后，可以提高通用性。
形参（形式上的参数）：定义 函数时，小括号中的参数，是用来接收参数用的，在函数内部作为变量使用。
实参（实实在在的数据）：调用 函数时，小括号中的参数，是用来把数据传递到函数内部用的。
4、函数的嵌套调用
①打印分割线：
def test1():
print("*" * 50)
def test2():
print("+" * 50)
test1()
print("-" * 50)
test2()
②打印由任意字符组成的分割线：
def line(char):
print(char * 50)
line("U")
③打印由 任意个数 任意定义字符 组成的分割线：
def line(char, time):
print(char * time)
line("Yilia", 10)
④定义一个能够打印5行的分割线，分割线由任意个数任意定义字符组成：
针对需求的变化，不要轻易修改之前已经完成的，能够正常执行的函数。
def lines(char, time):
"""
:param char: 分割线使用的分隔字符
:param time: 分隔字符的重复次数
"""
i = 0
while i < 5:
print(char * time)
i += 1
lines("*", 10)
ctrl Q：
八、模块
模块好比工具包，import 模块名；模块可以让曾经写过的代码被复用；
每一个以.py结尾的python源文件都是一个模块；
在模块中定义的 全局变量、函数 都是模块能够提供给外界直接使用的工具；
导入之后，可以使用模块名.变量 / 模块名.函数的方式，使用这个模块中定义的变量或函数。
应用：
函数的嵌套调用.py：
def lines(char, time):
"""
:param char: 分割线使用的分隔字符
:param time: 分隔字符的重复次数
:return:
"""
i = 0
while i < 5:
print(char * time)
i += 1
name = "Yilia"
模块.py：
import 函数的嵌套调用
函数的嵌套调用.lines("*", 20)
print(函数的嵌套调用.name)
模块名不能以数字开头，模块名也是标识符。
九、非数字型变量具体介绍
1、列表
①list（列表）是python中使用最频繁的数据类型，在其他语言中通常叫做 数组，专门用于存储一串信息；
②列表用[]定义，数据之间使用,分隔；
③列表的索引从0开始。索引 就是数据在 列表 中的位置编号，索引 又可以被称为 下标。在列表中取值时，如果超出索引范围，程序就会报错。
列表名称.然后输入Tab，就可以看到这个列表的所有 方法名 ：
函数名(参数)
对象.方法名(参数)
“增加”“修改”“删除”应用：
# 1、定义列表
list_name = ["黛玉", "宝玉", "宝钗"]
# 2、打印列表
print("列表内容为:%s" %list_name)
# 3、取值
print("列表索引为0的值为：%s" %list_name[0])
# 4、取索引
print("列表中 取值为<宝玉>的索引为：%s" % list_name.index("宝玉"))
# 5、修改列表
list_name[2] = "探春"
print("在列表末尾增加<探春>：%s" %list_name)
# 6、增加数据
# 在指定索引位置插入数据
list_name.insert(1, "元春")
print("在索引为1的位置增加<元春>：%s" %list_name)
# 在列表末尾追加数据
list_name.append("惜春")
print("在列表末尾追加<惜春>为：%s" %list_name)
# 将一个列表的完整内容追加到另一个列表末尾
list_ning = ["尤二姐", "秦可卿"]
list_name.extend(list_ning)
print("将一个列表完整追加到现有列表末尾：%s" %list_name)
# 7、清空列表
list_ning.clear()
print("清空列表：%s" %list_ning)
# 8、删除指定数据
list_name.remove("惜春")
print("删除惜春：%s" %list_name)
# 9、pop默认把列表中最后一个数据删除，也可以删除指定索引的值
list_name.pop()
print("pop把列表中最后一个数据删除：%s" %list_name)
list_name.pop(2)
print("pop删除指定索引的元素：%s" %list_name)
# del（delete）从内存中删除指定索引的元素
del list_name[3]
print("del删除指定索引的数据：%s" %list_name)
输出：
如果使用del将变量从内存中删除，后续的代码就不能继续使用这个变量了。在日常开发中，建议使用列表提供的方法删除，不要用del。
x = 123
del x
print(x) # 因为已经用del删除了x，所以再次打印就会报错
输出：
“统计”与“排序”应用：
# 1、统计
# len(length)函数可以统计列表中元素总数
list_name = ["黛玉", "宝玉", "宝钗", "宝玉"]
print("列表长度为%s" % len(list_name))
# count方法可以统计列表中元素出现的总数
number = list_name.count("宝玉")
print("列表中<宝玉>出现的次数为%s" % number)
print("字符串列表为%s" % list_name)
# 2、排序
list_number = [20, 8, 16, 35]
print("数字列表为%s"% list_number)
# 翻转
list_name.reverse()
print("字符串列表翻转之后为%s" % list_name)
list_number.reverse()
print("数字列表翻转之后为%s" % list_number)
# 升序
list_name.sort()
print("字符串列表升序之后为%s" % list_name)
list_number.sort()
print("数字列表升序之后为%s" % list_number)
# 降序
list_name.sort(reverse=True)
print("字符串列表降序之后为%s" % list_name)
list_number.sort(reverse=True)
print("数字列表降序之后为%s" % list_number)
输出：
循环遍历：从头到尾（顺序）依次从列表中获取数据，在循环体内部针对每一个元素，执行相同的操作。在python中为了提高列表的遍历效率，专门提供的迭代iteration遍历。使用for就能够实现迭代遍历：
# for 循环内部使用的变量 in 列表
for name in list_name:
循环内部针对列表元素进行操作
print(name)
尽管列表中可以存储多种数据类型，但是在实际开发中，更多地是：
在列表中存储相同类型的数据
通过迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作。
应用：
list_name = ["黛玉", "宝玉", "宝钗", "宝玉"]
for name in list_name:
print(name)
输出：
2、元组
Tuple元组与列表类似，不同之处在于 元素不能修改；
元组表示 多个元素组成的序列，元组在python开发中，有特定的应用场景。
用于存储遗传信息，数据之间使用,分隔；
元组用()定义。创建空元组：tuple = ()；
元组的索引从0开始，索引就是数据在元组中的位置编号
应用：
info_tuple = ("林黛玉", 1, 2.3)
print(info_tuple)
print(type(info_tuple))
#取值
print(info_tuple[0])
#取索引
print(info_tuple.index(1))
#统计元组中指定元素的个数
print(info_tuple.count("林黛玉"))
输出：
元组中只包含一个元素时，需要在元素后面添加逗号。如果python解释器发现前面有括号，后面有括号，会自动把关注点放到括号内部。
single_tuple = (5,)
print(type(single_tuple))
single_tuple_one = (5)
print(type(single_tuple_one))
元组中通常保存的数据类型是不同的，所以针对元组变量循环遍历的需求不是很多。
info_tuple = ("林黛玉", 1, 2.3)
for my_info in info_tuple:
print(my_info)
应用场景：
①作为函数的参数和返回值，让一个函数可以接收任意多个参数，或者一次返回多个数据。
info_tuple = (“贾宝玉”, 14, 1.65)
print("%s年龄%d，身高%.02f" % info_tuple)
②格式字符串，格式化字符串后面的()本质上就是一个元组
③让列表不可以被修改，以保护数据安全。把列表放到tuple中：
tuple(列表)
同理，可以把希望修改的列表放到list中：
list(列表)
3、字典
dictionary字典是 除列表以外 ，python之中 最灵活 的数据类型。字典同样可以用来存储 多个数据（描述一个物体的相关信息） 。
和列表的区别：
列表 是 有序 的对象集合
字典 是 无序 的对象集合。人们更关心字典中保存的数据，不关心数据顺序。
字典用
{}定义
字典使用 键值对 存储数据
键key是索引，用于获取数据
值value是数据，用于保存数据
键和值之间使用:分隔
多个键值对之间采用,分隔
键必须是唯一的，只能使用 字符串、数字或元组 ；
值可以取任何数据类型 。
使用字典输出时，通常输出顺序与定义顺序是不一致的。
怡红公子 = {"name": "贾宝玉" # "name"是键，"贾宝玉"是值，凑一块就是键值对
, "age": 14
, "height": 1.65
, "home": "怡红院"
, "gender": True
}
print(怡红公子)
# 1、输出字典中的键值对个数
len(怡红公子)
print("输出字典的键值对个数：%s" % len(怡红公子))
# 2、取值，取出指定key对应的值
print(怡红公子["name"])
# 3、如果key不存在，就会增加键值对；如果key存在，就会修改键值对
# 增加值
怡红公子["丫鬟"] = "袭人"
print(怡红公子)
# 修改
怡红公子["name"] = "无事忙"
print(怡红公子)
# 4、删除指定key的键值对。如果key不存在，程序会报错。
怡红公子.pop("gender")
print(怡红公子)
# 5、合并字典。新name会替换原有name
妹妹 = {"name":"贾宝玉"
,"大妹妹": "贾迎春"
, "二妹妹": "贾探春"
, "三妹妹": "贾惜春"
}
怡红公子.update(妹妹)
print(怡红公子)
# 6、清空字典
print(怡红公子.clear())
遍历 就是 依次 从字典中获取所有键值对。实际开发中，针对字典的遍历需求不多。
怡红公子 = {"name": "贾宝玉" # "name"是键，"贾宝玉"是值，凑一块就是键值对
, "age": 14
, "height": 1.65
, "home": "怡红院"
, "gender": True
}
for k in 怡红公子:
print(k, end=":")
print(怡红公子[k])
输出：
尽管可以使用for in遍历字典，但是在开发中，更多的应用场景是：
①使用多个键值对，存储描述一个
物体的相关信息——描述更复杂的数据信息；
②将多个字典放在一个列表中，再进行遍历，在循环体内部针对每一个字典进行相同的处理。
大观园_list = [
{"name": "贾宝玉"
, "home": "怡红院"
, "丫鬟": "袭人"
}
, {"name": "林黛玉"
, "home": "潇湘馆"
, "丫鬟": "紫鹃"
}
]
for list_info in 大观园_list:
print(list_info)
4、字符串
字符串就是一串字符，是编程语言中表示文本的数据类型。在python中可以使用一对双引号""（ 大多数编程语言都使用双引号）或者一对单引号''定义字符串。在实际开发中，一般不使用转义字符\'或\"定义字符串：
如果字符串内部需要使用
"，可以使用'定义字符串
如果字符串内部需要使用'，可以使用"定义字符串
# 双引号和单引号的用法
str1 = '林黛玉的外号叫"潇湘妃子"'
print(str1)
str2 = "黛玉字为'颦颦'"
print(str2)
可以使用索引的方式[]获取 一个字符串中指定位置的字符，索引计数从0开始。
strl = "贾宝玉的外号叫'怡红公子'" # 双引号和单引号的用法
print("字符串为%s" % strl)
print("字符串的长度为%d" % len(strl))
# 如果输入一个字符串中不存在的元素，系统不会报错，输出结果为0
print("'宝'出现的次数为%s" % strl.count("宝"))
print("索引为5的元素为%s" % strl[5])
# 如果使用index方法查找的元素不存在，就会报错
print("'玉'的索引为%d" % strl.index("玉"))
也可以使用for循环遍历字符串中每一个字符：
strl = "贾宝玉的外号叫'怡红公子'" # 双引号和单引号的用法
for i in strl:
print(i, end="")
方法①判断类型：
在python中，空格、\t、\n、\r都属于 空白字符
str = " \n \t \r"
print(str.isspace())
str_1 = “a b c”
print(str_1.isspace())
isdecimal、isdigit、isnumeric 都不能判断小数。如果是小数，都会返回False。这三个方法依次判断的范围增大，在开发中建议使用isdecimal。
unicode字符串 ：在键盘上无法直接输入，需要通过其他输入法输入。如"\u00b2"输出结果为²（平方符号）。
方法②查找和替换
str = "Yilia loves music"
# 1、判断是否以指定字符串开始
print(str.startswith("Yilia"))
print(str.startswith("yilia"))
# 2、判断是否以指定字符串结束
print(str.endswith("music"))
# 3、查找指定字符串
print(str.find("love"))
print(str.find("cheng")) # 如果指定字符串不存在，会返回-1
# 4、替换字符串
# replace方法执行完后会返回一个新的字符串，不会更改原来的字符串
print(str.replace("music", "watching movie"))
print(str)
输出：
方法③大小写转换
方法④文本对齐
居中应用：
poem = ["《相思》"
, "王维"
, "红豆生南国，春来发几枝"
, "愿君多采撷，此物最相思"
]
# 打印诗歌
for i in poem:
print(i)
#居中打印诗歌
for i in poem:
print(i.center(11))
# 默认填充英文空格，发现对齐效果不是很好。中文空格比英文空格跨度大
crtrl Q：查看center参数#fillchar 改为中文空格
for i in poem:
print(i.center(11, " ")) # fillchar选为中文空格（此处空格为什么和英文空格一样大？不懂）
方法⑤去除空白字符
poem = ["\n\t《相思》"
, "王维\t"
, "红豆生南国，春来发几枝"
, "愿君多采撷，此物最相思"
]
# 打印诗歌
for i in poem:
print(i)
# 去除首尾空白字符
for i in poem:
print(i.strip())
方法⑥拆分和连接
poem_str = "\n\t《相思》\n王维\t曾经沧海难为水，除却巫山不是云。\n取次花丛懒回顾，半缘修道半缘君"
print(poem_str)
# 1、拆分字符串
poem_str_1 = poem_str.split()
print(poem_str_1)
# 2、合并字符串
result = " ".join(poem_str_1)
print(result)
字符串中的切片
切片适用于 字符串、列表、元组
切片 使用 索引值 来限定范围，从一个大的字符串中切出小的字符串
列表 和 元组 都是有序的集合，都能够通过 索引值 获取到对应的数据
字典 是一个 无序 的集合，是使用键值对保存数据
顺序0 1 2 3 4 5...，倒序...-3 -2 -1。
字符串[开始索引:结束索引:步长]
不包含结束索引的内容，例如[0:2:1]内容为py
[0::1] # 不指定结束索引，就可以实现完整切片。
num_str = "0123456789"
print("num_str：%s" % num_str)
print("num_str[1:6]：%s" % num_str[1:6])
print("num_str[3:]：%s" % num_str[3:])
print("num_str[:6]：%s" % num_str[:6])
print("每隔一个取一个num_str[0::2]：%s" % num_str[0::2]) # 每隔一个取一个
print("num_str[1::2]：%s" % num_str[1::2])
print("取出全部num_str[:]：%s" % num_str[:]) # 全部
print("num_str[2:-1]：%s" % num_str[2:-1])
print("取出倒数两个字符num_str[-2:]：%s" % num_str[-2:]) # 取出倒数两个字符
print("字符串的逆序num_str[::-1]：%s" % num_str[::-1]) # 字符串的逆序
输出：
5、公共方法
（1）python的内置函数
str = "life_is_like_a_chocolate"
print(max(str))
print(min(str))
print(len(str))
# max()、min()只会对字典的key比大小，不会对值比大小
str1 = {
"a": "z"
, "b": "y"
, "c": "x"
}
print("max(str1)为%s" % max(str1))
print("min(str1)为%s" % min(str1))
print("列表比大小：%s" % ([1, 1, 1] < [2, 2, 2]))
print("字符串比大小：%s" % ("aaa" < "zzz"))
print("元组比大小：%s" % ((1, 1, 1) < (2, 2, 2)))
输出：
（2）切片
字典 不支持切片；
列表、元组、字符串 支持切片。
print(([0, 1, 2, 3, 4, 5][1:3])) # 列表切片
print((0, 1, 2, 3, 4, 5)[1:3]) # 元组切片
print(("012345"[1:3])) # 字符串切片
（3）运算符
append 把[3, 4]作为一个整体放入list，而 extend 把[3, 4]作为单独元素放入list。
# 加号操作执行完后会生成一个新的列表，而expend是在原列表的基础上生成的。
# 元组相加
print((1, 2) + (3, 4)) # 输出：(1, 2, 3, 4)
list = [1, 2]
# 列表相加
print(list) # 输出：[1, 2]
print(list + [3, 4]) # 输出：[1, 2, 3, 4]
list.append([3, 4])
print(list) # 输出：[1, 2, [3, 4]]。把[3, 4]作为一个整体放入list
list.extend([3, 4])
print(list) # 输出：[1, 2, [3, 4], 3, 4]
# 字符串相加
print("12" + "34") # 输出：1234
# 元组重复
print(((1, 2) * 5)) # 输出：(1, 2, 1, 2, 1, 2, 1, 2, 1, 2)
# 列表重复
print([1, 2] * 5) # 输出：[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
# 字符串重复
print("12" * 5) # 输出：1212121212
in在对字典操作时，判断的是 字典的键；
in和not in被称为 成员运算符
print("a" in "abc") # True
print("a" not in "abc") # False
print(1 in [0, 1, 2]) # True
print(1 not in [0, 1, 2]) # False
print("a" in {"a": "Yilia"}) # True
print("Yilia" in {"a": "Yilia"}) # False
（4）完整的for循环语法
for 变量 in 集合:
循环体代码
else:
只要没有通过break退出循环，循环结束后就会执行else的代码
例：
str = "wa"
for i in str:
print(i)
else:
print("hahaha")
应用：
在迭代遍历嵌套的数据类型时，例如 一个列表包含了多个字典
需求：要判断 某一个字典中 是否存在 指定的 值。
如果存在，提示并且退出循环；
如果不存在，在循环整体结束后，希望得到一个统一的提示。
yi_hong_yuan = [{"name": "袭人"}, {"name": "摄月"}, {"name": "晴雯"}, {"name": "秋纹"}]
# 搜索指定的姓名
find_name = "碧痕"
for girls in yi_hong_yuan:
print(girls)
if girls["name"] == find_name:
print("找到了%s" %find_name)
break # 如果已经找到了，就终止循环
else:
print("没有找到%s" % find_name)
print("循环结束")
输出：
如果find_name = "晴雯"，输出为：
for循环中的else与if条件中的else区别：
①
for循环中，当循环执行完毕时，如果依然没有找到搜索的内容，才会执行一次else中的内容；
②if循环中，循环每执行一次，都会执行else中的内容
7849
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
