Python学习总结

第一个python程序

print("Hello World")

# 缩进一般4个空格键或者1个tab键，但是所有代码块语句必须是相同的缩进，这个必须严格执行，不同的缩进会导致程序不能运行，不能混用空格和tab
if True:
    print ("True")
else:
    print ("False")

python注释符

单行注释 （行注释）
# print("Hello World")

多行注释 （块注释）
'''
print("Hello World")
'''
# 或者
"""
print("Hello World")
"""

编码与解码

编码

str = "Hello, 你好!"
encoded_str = str.encode()  # 默认使用UTF-8编码
print(encoded_str) 
# 输出：b'Hello, \xe4\xbd\xa0\xe5\xa5\xbd!'

解码

str = b'Hello, \xe4\xbd\xa0\xe5\xa5\xbd!'
decoded_str = str.decode()  # 默认使用UTF-8解码
print(decoded_str)
# 输出：Hello, 你好!

变量的定义

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。在 Python 中，变量就是变量，它没有类型。

# 单个变量赋值
qq_number = "123456"
# 多个变量赋值
a = b = c = 100

变量的命名规范

• 标识符是程序中某一元素（变量、关键字、函数、类、模块、对象）的名字
• 标识符由字母（ A~Z , a~z ）、数字（0-9）、以及下划线（_）组成。
• 取变量名要避开这些关键字

# 以下是Python的关键字
import keyword
print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

# 每个单词都小写
first_name,my_school_num 
# 小驼峰
firstName
# 大驼峰
FirstName

变量的类型

• 数字型
  整型(int)、长整型(long)、浮点型 (float )、布尔型 (bool)、复数型(complex)
• 非数字型
  字符串、列表、元组、字典
• 布尔零值

 真 True 非0数--非零即真
 假 False
 
 等同于True的值：
 -非零数值
 -非空字符串
 
 等同于False的值：
 None；
 False；
 任何为0的数字类型，如0、0.0、0j；
 任何空序列，如""、()、[]；
 空字典，如{}；
 用户定义的类实例，如类中定义了__bool__()或者__len__()方法，并且该方法返回0或者布尔值False。

• 定义不同类型的变量

# Python 解释器会根据赋值语句等号右侧的数据自动推导出变量中保存数据的准确类型
name = "小明"
age = 18
sex = true
high = 1.75
weight = 75.0
b = True
c = False

# 查看数据类型
print(type(name))

first_name = "san"
last_name = "zhang"

# 字符串使用+号进行计算是拼接的意思 会生成新的字符串
print(first_name + last_name)
# 字符串使用*号进行计算是重复拼接的意思 会生成新的字符串
print("-" * 50)

变量的输入

# input输人的任何内容都会被当做字符串 回结果为字符串 str 类型
name = input("请输入用户名")
passwd = input("请输入密码")
print(type(passwd))

数据类型转换

int(x) 将x转换为一个整数
float(x) 将x转换为一个浮点数

num2 = int(input("请输入一个整数"))
print(num2 + 1)

python运算符

• python算数运算符

运算符	描述	实例
+	加	10 + 20 = 30
-	减	10 - 20 = -10
*	乘	10 * 20 = 200
/	除	10 / 20 = 0.5
//	取整除	返回除法的整数部分 (商) 9 // 2 = 4
%	取余数	返回除法的余数 9 % 2 = 1
**	幂	又称次方、乘方， 2 ** 3 = 8

• python比较运算符

比较运算符包括：等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）和小于等于（<=）
所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量 True 和 False 等价

= 赋值
== 比较是否相等 
=== 恒等于

• python逻辑运算符
  and 、或or 和 非not 三种

age = int(input("请输入年龄"))
if age >= 0 and age <= 120:
    print("您是个人")
else:
    print("您不是个人")

• python赋值运算符

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	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

• python身份运算符

运算符	描述	实例
is	is 是判断两个标识符是不是引用同一个对象	x is y，类似 id(x) == id(y)
is not	is not 是判断两个标识符是不是引用不同对象	x is not y，类似 id(a) != id(b)

is与 == 区别

# is用于判断两个变量引用对象是否为同一个
# ==用于判断 引用变量的值是否相等

a = [1,2,3]
b = [1,2,3]
if b is not a:
    print(a is b)

if b == a:
    print(b == a)

"""
返回结果
False
True
"""

• python运算符优先级

优先级	运算符	描述	结合性
19	()	小括号	无
18	x[i]	索引运算符	左
17	x.attribute	属性访问	左
16	**	乘方 (指数)	右
15	~	按位取反	右
14	+, -	正号，负号	右
13	*, /, %, //	乘，除，取模，取整除	左
12	+, -	加号，减号	左
11	>>, <<	右移动运算符，左移动运算符	左
10	&	按位与运算符	右
9	^	按位异或运算符	左
8	`	`	按位或运算符
7	==, !=, <=, <, >, >=	等于，不等于，小于等于，小于，大于，大于等于	左
6	is, is not	身份运算符	左
5	in, not in	成员运算符	左
4	not	逻辑运算符非	右
3	and	逻辑运算符与	左
2	or	逻辑运算符或	左
1	exp1, exp2	逗号运算符	左

变量的格式化输出

格式化字符	含义
%s	字符串
%d	有符号十进制整数，%06d 表示输出的整数显示位数，不足的地方使用 0 补全
%f	浮点数，%.02f 表示小数点后只显示两位
%%	输出 %

• 格式化输出（%）

# print("%格式化字符串 + 其他输出内容" % 变量1)
# print("%格式化字符串 + 其他输出内容" % (变量1，变量2...))

number = 6
print("My lucky number is %d" % number)

# %.2f表示字符串保留小数点后两位  同理%6d表示整数位数保持6位 %06d表示位数不够用0填充
print("苹果单价是 %.2f 元/斤，%.2f 斤的苹果需要支付 %.2f元" % (price, weight, money))

• 格式化输出（format）

# 不设置指定位置，按默认顺序
print("{} is a beautiful {}！".format("Beijing","city"))

# 设定指定位置 0 代表Beijing 1代表 city
print("{0} is a beautiful {1}!".format("Beijing", "city"))
print("{1} is a beautiful {2}!".format("Tianjin","Beijing", "city"))  # 按照位置参数显示具体的值

# 设置位置参数名称
print("{name1} is a beautiful {name2}!".format(name1="Beijing", name2="City"))

# 混合使用
#可以通过索引，参数名混合进行匹配
print("{0} is a beautiful {name}!".format("Beijing", name="city"))
#可以通过默认顺序和参数名混合进行匹配，但命名参数必须写到最后
print("{} is a beautiful {name}!".format("Beijing", name="city"))

# 通过对象的属性匹配参数
class Names:
    Name1 = "Beijing"
    Name2 = "city"

str1 = "{names.Name1} is a beautiful {names.Name2}!".format(names=Names)
print(str1)

# 通过字典设置参数
# 匹配字典中的参数
dict = {"name1": "Beijing", "name2": "city"}
str1 = "{name1} is a beautiful {name2}!".format(**dict)
print(str1)

# 通过列表索引设置参数
list = ["Beijing", "city"]  #① 匹配列表中的参数
str1 = "{} is a beautiful {}!".format(*list)
str2 = "{1} is a beautiful {0}!".format(*list)

• f-string 格式化字符串

name = 'Runoob'
print(f'Hello {name}')  # 替换变量
print(f'{1+2}')         # 使用表达式
w = {'name': 'Runoob', 'url': 'www.runoob.com'}
print(f'{w["name"]}: {w["url"]}')

• 换行输出

# print 默认输出是换行的，此外，在变量末尾加上 end=“\n” 可以在多个 print 函数的输出结果中实现换行

print("我", end="\t")
print("爱", end="")
print("你", end="\n")
print("们")

• 更换间隔字符输出

# print() 函数一次性输出的两个字符串使用空格分隔，在变量末尾加上参数 sep =“” 可以修改间隔字符
print("www", "runoob", "com")
print("www", "runoob", "com", sep=".")
print("www", "runoob", "com", sep="/")

执行以上代码，输出结果为：
wwwrunoobcom
www.runoob.com
www/runoob/com

判断语句

import random
while True:
    try:
        person = int(input("请输入你要输入的石头(1) /剪刀 (2) /布 (3)"))
    except ValueError as e:
        print(e)
        continue
    if 1 <= person <= 3:
    	# random.randint(a,b) 生成指定范围内的整数
        computer = random.randint(1,3)
        if person == computer:
            print("平局")
        elif (person == 1 and computer ==2) or (person == 2 and computer ==3) or (person ==3 and computer ==1):
            print("玩家胜")
        else:
            print("电脑胜") 

三元表达式

age = 20

cn = "成年" if age >= 18 else "未成年"
print(cn)

# 返回多个条语句
cn = "成年", "大于18" if age >= 18 else "未成年"
print(cn)

# 在函数内部使用三元表达式
def even_num(num):
    return True if num % 2 == 0 else False

while循环语句

i = 0
while i <= 10:
    if i ==5:
        print(i)
        break    
    i+=1
print(result)

# pass 是空语句，pass 不做任何事情，表示一个占位符
while True:
	pass

# 如果 while 后面的条件表达式判定为 False 时，则执行 else 的代码块
while 条件表达式：
    代码块（循环体）
else:
    代码块

for 循环

for letter in 'Python':     # 第一个实例
   print("当前字母: %s" % letter)

# range 函数是 Python 中的内置函数，用于生成一系列连续的整数
# ange 函数的一般语法格式为：range(start, stop, step)
for num in range(10,20): 
	 print(num)

for x in range(1, 8, 2):
    print(x)

列表

• List(列表)通常叫做数组
• 列表的索引从0开始
• 列表（list）是一个有序且可更改的序列，允许重复

name_list = ["liyue","wangwei","hezhizhang"]
name_list = list("liyue")

列表的切片 listname[start : end : step]， step 表示步长

a = [1,2,3,4,5,6,7,8,9]
print(a[0])
print(a[-5])
print(a[0:4])
print(a[0:5:2])
print(a[0:])
print(a[:-1])
print(a[:])

列表的基础操作

# 列表的组合
a = ["h", "e", "l", "l", "o"]
b = ["w", "o", "r", "l", "d"]
c = a + b
print(c)

# 列表的重复
print(a*3)

# 列表的长度
print(len(a))

# 返回列表中元素最小值和最大值
a = [1,2,3,4,5,6,7,8,9]
print(max(a))
print(min(a))

# 返回列表中元素的总和
print(sum(a))

列表进阶的操作

name_list = ["liyue","wangwei","hezhizhang"]

print(name_list[1]) # 取值
print(name_list.index("liyue")) # 取索引

name_list[1] = "lisi" #修改列表某个元素的值
name_list.append("zhaoliu") # append向列表末尾追加数据
name_list.insert(1,"xiaomeimei") # insert向指定索引位置插入数据

temp_list = ["孙悟空","猪八戒","沙师弟"]
name_list.extend(temp_list) # extend扩展将另一个列表的数据追加到列表末尾

name_list.remove("wangwu") # remove 从列表删除指定的数据
name_list.pop() # pop 默认删除最后一个元素
name_list.pop(3) # pop删除指定索引位置的数据
name_list.clear() # clear删除列表全部元素
del name_list[1] # 注意: 如果使用 del 关键字将变量从内存中删除, 后续的代码就不能再使用这个变量了

list_len = len(name_list) # len统计列表中有多少个元素
count = name_list.count("zhangsan") # count统计列表中某个元素出现的次数

name_list.sort() # sort 将列表中的元素按照升序排列
name_list.sort(reverse=True) # 反向排序
name_list.reverse() # 逆序排列 反转列表从后往前输出
print(name_list)

a = [[10, 20, 30], ["q", "w"], ["d", 1]] # 列表的嵌套
print(a[0])

# 列表的for循环遍历
for name in name_list:
    print(name)

元组

• 元组的元素不能修改
• 元组的索引从0开始
• 元组（tuple）是一个有序且不可更改的集合，允许重复
• 元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列

info_tuple = ("zhangsan",18,17.5) # 元组创建的语法
info_tuple = () # 创建空元组
info_tuple = (5,) # 创建一个元素的元组
info_tuple = tuple("hello") # 内置函数tuple创建元组

元组的索引

# 元组正向索引从 0 开始，第二个索引是 1，依此类推；也可以反向索引，最后一个元素的索引为 -1，往前一位为 -2，以此类推。
name_list = ("zhangsan", "liyue", "wangwei", "hezhizhang", "zhangsan")

name_list[0] # 元组的访问

# 元组的截取
print(name_list[0])
print(name_list[-5])
print(name_list[0:4])
print(name_list[0:5])
print(name_list[0:5:2])

print(len(name_list)) # 元组的长度
print(name_list * 2) # 元组的复制

# 判断元组中是否存在某元素，存在，返回 True；如果不存在，返回 False。
print("wangwei" in name_list)

print(name_list.index("wangwei")) # 查找内容的位置
print(name_list.count("zhangsan")) # 统计元组中zhangsan出现的次数
print(len(name_list)) # 统计元组中出现的元素的个数
del name_list1 # 元组的删除，元组被删除后，再次使用变量会有异常信息。

# 连接多个元组
name_list2 = ("heigou", "dagou", "sigou", "mugou", "gonggou")
name_list3 = name_list2 + name_list1

# 元组的遍历
for i in name_list1:
    print(i, end="\t")

元组和列表之间的转换

# tuple 函数可以把列表转换成元组
num_list = [1,2,3,4,5,6,7,8,9]
num_tuple = tuple(num_list)

# list函数可以把元组转换成列表
num_tuple = (1,2,3,4,5,6,7,8,9)
num1_list = list(num_tuple)

元组的应用场景

• 函数的参数和返回值
• 格式化字符串后面的()本质上就是一个元组
• 让列表不可以被修改，以保护数据安全(比如：经纬坐标)

info_tuple = ("小明",18,1.75)

print("我的名字叫 %s 年龄 %d 身高%.2f" % ("小明",18,1.75)) # 一般写法
print("我的名字叫 %s 年龄 %d 身高%.2f" % info_tuple) # 也可以这么写

info_str = "我的名字叫 %s 年龄 %d 身高%.2f" % info_tuple # 元组也可以拼接字符串组成新的字符串

字典

• 键key 是索引，必须是唯一的，并且数据类型只能是字符串、数字或元组
• 值value 是数据，可以取任何数据类型

xiaoming_dict = {"name":"xiaoming","age":18,"height":185,"gender":True} # 字典的语法格式

# 通过 dict 函数创建字典
demo1 = [('two', 2), ('one', 1), ('three', 3)]
demo2 = [['two', 2], ['one', 1], ['three', 3]]
dict(demo1)
dict(demo2)

print(xiaoming_dict["name"]) # 取值
print(xiaoming_dict["name123"]) # 取值不存在时会报错！
xiaoming_dict.get("name") # get 函数访问，当指定的键不存在时，get 函数不会抛出异常和报错会返回 None
xiaoming_dict["weight"] = 195 # 增加字典内容，如果key不存在就是新增
xiaoming_dict["weight"] = 175 # 修改字典内容，如果key存在就是修改
xiaoming_dict.pop("name") # 删除

print(len(xiaoming_dict)) # 统计键值对数量
xiaoming_dict2 = xiaoming_dict.copy() # 复制字典
xiaoming_dict.clear() # 清空字典
print("name" in xiaoming_dict) # 判断字典中是否存在指定键值对

# 合并字典
temp_dict = {"weight":175}
xiaoming_dict.update(temp_dict) # 如果被合并的字典中包含已经存在的键值对，会覆盖原有的键值对

print(xiaoming_dict.keys()) # 返回字典中的所有key
print(xiaoming_dict.values()) # 返回字典中所有键对应的value
print(xiaoming_dict.items()) # 回字典中所有的键值对

# 遍历字典，通过Key遍历
for key in xiaoming_dict:
    print("%s : %s" % (key,xiaoming_dict[key]))

# 遍历字典，通过键值对遍历
for key,value in xiaoming_dict.items():
    print(key, value)

# 遍历字典列表
card_list = [{"name": "张三", "qg":"12345", "phone":"110"},{"name":"委四","qg":"54321","phone":"10086"}]

for card_info in card_list:
	print(card_info)

集合

• 集合（set）是一个无序的不重复元素序列
• 集合中，只能存储整型、浮点型、字符串、元组这些不可变的数据类型，无法存储列表、字典、集合这些可变的数据类型

set1 = {1, 2, (3, 4, "a"), "b", "b"} # 集合的语法格式
set1 = set("hello") # set 函数创建集合

集合的基础操作

# 集合的遍历
test = {10010, 20020, "apple", "orange", (10010, 20020, "orange", "banana")}
for i in test:
    print(i, end="\n")

del test # 集合的删除
test.add(30030) # 元素的添加
test.remove("orange") # 元素的删除,移除一个不存在的元素时会发生错误
test.discard(10010) # 元素的删除,移除一个不存在的元素时不会发生错误
test.clear() # 清空集合
test.pop() # 随机删除集合中的某个元素
test2 = test.copy() # 集合的复制

# 集合的运算
set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1 & set2) # 集合的交集, 取两集合公共的元素
print(set1 | set2) # 集合的并集, 取两集合全部的元素
print(set1 - set2) # 集合的差集, 取一个集合中另一集合没有的元素
print(set1 ^ set2) # 集合的对称差集, 取set1和set2中不属于 set1 & set2 的元素

字符串

str = 'hackone' # 单引号表示字符串
str = "hackone" # 双引号表示字符串

# 三引号表示多行字符串，三引号中可以自由的使用单引号和双引号
str = '''hackone
hackone
hackone'''

# 编码和解码
str = "我爱Python"
str_en = str.encode("UTF-8") # 结果, b'\xe6\x88\x91\xe7\x88\xb1Python'
str_de = str_en.decode("UTF-8") # 结果, 我爱Python

'ABC'.encode('ascii')  # 编码
b'ABC'.decode('ascii') # 解码

# 遍历字符串
string = "hello world"
for c in string:
	print(c)

判断字符串类型

方法	说明
string.isspace()	如果 string 中只包含空格，则返回 True
string.isalnum()	如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True
string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True
string.isdecimal()	如果 string 只包含数字则返回 True，全角数字
string.isdigit()	如果 string 只包含数字则返回 True，全角数字、(1)、\u00b2
string.isnumeric()	如果 string 只包含数字则返回 True，全角数字，汉字数字
string.istitle()	如果 string 是标题化的(每个单词的首字母大写)则返回 True
string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True
string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True

字符串查找和替换

方法	说明
string.startswith(str)	检查字符串是否是以 str 开头，是则返回 True
string.endswith(str)	检查字符串是否是以 str 结束，是则返回 True
string.find(str, start=0, end=len(string))	检测 str 是否包含在 string 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如是返回开始的索引值，否则返回 -1
string.rfind(str, start=0, end=len(string))	类似于 find() 函数，不过是从右边开始查找
string.index(str, start=0, end=len(string))	跟 find() 方法类似，只不过如果 str 不在 string 会报错
string.rindex(str, start=0, end=len(string))	类似于 index()，不过是从右边开始
string.replace(old_str, new_str, num=string.count(old))	把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次

字符串大小写转换

方法	说明
string.capitalize()	把字符串的第一个字符大写
string.title()	把字符串的每个单词首字母大写
string.lower()	转换 string 中所有大写字符为小写
string.upper()	转换 string 中的小写字母为大写
string.swapcase()	翻转 string 中的大小写

字符串文本对齐

方法	说明
string.ljust(width)	返回一个原字符串左对齐，并使用空格填充至长度 width 的新字符串
string.rjust(width)	返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串
string.center(width)	返回一个原字符串居中，并使用空格填充至长度 width 的新字符串

字符串去除空白字符串

方法	说明
string.lstrip()	截掉 string 左边（开始）的空白字符
string.rstrip()	截掉 string 右边（末尾）的空白字符
string.strip()	截掉 string 左右两边的空白字符

字符串拆分和连接

方法	说明
string.partition(str)	把字符串 string 分成一个3元素的元组 (str前面,str,str后面)
string.rpartition(str)	类似于partition()方法，不过是从右边开始查找
string.split(str="", num)	以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个子字符串，str 默认包含 \r, \t, \n 和空格
string.splitlines()	按照行(\r, \n, \r\n)分隔，返回一个包含各行作为元素的列表
string.join(seq)	以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串

字符串的切片

• 切片方法适用于字符串、列表、元组
• 切片区间属于左闭开型[开始索引，结束索引) => 开始索引 >= 范围结束索引
• 切片索引倒数第一是-1，倒数第二是-2，依此类推

# 字符串切片的语法格式
# 字符串[开始索引：结束索引：步长]
print(num_str[0:10:2])

num_str = "0123456789"
print(num_str[2:6]) # 截取队 2 ~ 5 位置 的字符串
print(num_str[2:]) # 截取从 2 ~末尾 的字符串
print(num_str[:6]) # 截取从 开始 ~ 5 位置的字符串
print(num_str[:]) # 截取完整的字符串
print(num_str[::2]) # 从开始位置，每隔一个字符截取字符串
print(num_str[1::2]) # 从索引 1 开始，每隔一个取一个
print(num_str[2:-1]) # 截取从 2 ~ 末尾 -1 的字符串
print(num_str[-2:]) # 截取字符串末尾两个字符
print(num_str[::-1]) # 字符串的逆序(面试题)

python的公共方法

函数	描述	备注
len(item)	计算容器中元素个数
del(item)	删除变量	del 有两种方式
max(item)	返回容器中元素最大值	如果是字典，只针对 key比较
min(item)	返回容器中元素最小值	如果是字典，只针对 key比较
cmp(item1,item2)	比较两个值, -1 小于/0 相等/1 大于	Python 3.x 取消了cmp函数

运算符	Python 表达式	结果	描述	支持的数据类型
+	[1,2] + [3,4]	[1,2,3,4]	合并	字符串、列表、元组
*	["Hi!"] * 4	["Hi!", "Hi!", "Hi!", "Hi!"]	重复	字符串、列表、元组
in	3 in (1,2,3)	True	元素是否存在	字符串、列表、元组、字典
not in	4 not in (1,2,3)	True	元素是否不存在	字符串、列表、元组、字典
> >= == < <=	(1,2,3) < (2,2,3)	True	元素比较	字符串、列表、元组

注意in 在对 字典操作时，判断的是字典的键in和not in 被称为成员运算符

python完整的for循环运算

for 变量 in 集合:
 	循环体代码
else：
	这里的代码for循环正常结束会执行，
	break退出的不会执行

for num in [1, 2, 3]:
    print(num)
    if num == 2:
    # 如果循环体内部使用break退出了循环# else 下方的代码就不会被执行
        break
else:
    print("会执行吗?")
print("循环结束")

函数

• 值传递：适用于实参类型为不可变类型（字符串、数字、元组）
• 引用传递：适用于实参类型为可变类型（列表，字典）

# 定义函数：返回 a 和 b 中的最大值
def max_ab(a, b):
    if type(a) == int and type(b) == int:
        return a if a >= b else b
    else:
        return '类型错误' # 处理结果返回

多返回值

def measure():
	"“返回当前的温度”"
	temp = 39
	wetness = 50
	# 元组- 可以包含多个数据，因此可以使用元组让函数一次返回多个值
	# 如果函数返回的类型是元组，小括号可以省略社
	# return (temp, wetness)
	return temp, wetness

# 第一种方式，接收返回值元组
result = measure()
print(type(result))
print(result[0])
print(result[1])

# 第二种方式，分开接收返回值
# 如果函数返回的类型是元组，同时希望单独的处理元组中的元素，可以使用多个变量
gl_temp,gl_wetness = measure()
print(gl_temp)
print(gl_wetness)

位置参数

# 必须按照正确的顺序将实际参数传到函数中

# 定义一个函数求梯形面积
def area_trapezoid(a, b, h):
    s = (a + b) * h / 2
    print(s)
area_trapezoid(1, 2, 6)

关键字参数

# 通过形参名称匹配参数，传参时顺序可以颠倒

# 定义一个函数求梯形面积
def area_trapezoid(a, b, h):
    s = (a + b) * h / 2
    print(s)
area_trapezoid(a=1, b=2, h=6)
area_trapezoid(b=2, h=6, a=1)
area_trapezoid(1, b=2, h=6)

缺省参数（默认参数）

# 给参数设置默认值

# 定义一个函数求梯形面积
def area_trapezoid(a, b, h=6):
    s = (a + b) * h / 2
    print(s)
area_trapezoid(a=1, b=2)
area_trapezoid(a=1, b=2, h=8)

# python原生的默认参数实例
gl_num_list = [6, 3, 9]
gl_num_list.sort() # 默认就是升序排序，因为这种应用需求更多
gl_num_list.sort(reverse=True) # 只有当需要降序排序时，才需要传递reverse’ 参数   这就是缺省参数

多值参数（可变长参数）

python中有两种多值参数:
	- 参数名前增加一个 * 可以接收元组
	- 参数名前增加两个 ** 可以接收字典

多值参数命名习惯:
	- *args存放元组参数，前面有一个* ，args是arguments 的缩写，有变量的含义
	- **kwargs存放字典参数，前面有两个** ，kw 是keyword 的缩写，kwargs 可以记忆键值对参数

def demo(a, b, *args):
    print(a, b, args)

demo(1, 2, 3)
demo(1, 2, 3, 4, 5, 6)

def demo(a, b, **kwargs):
    print(a, b, kwargs)
demo(1, 2)
demo(1, 2, c=3)
demo(1,2,name="小明",age=18,gender=True)

def demo(num,*args,**kwargs):
    print(num)
    print(args)
    print(kwargs)

demo(1,2,3,4,5,name="小明",age=18,gender=True)

多值参数中元组和字典的拆包

在调用带有多值参数的函数时，如果希望:
	- 将一个元组变量，直接传递给 args
	- 将一个字典变量，直接传递给 kwargs

就可以使用拆包，简化参数的传递，拆包的方式是:
	- 在元组变量前，增加一个*
	- 在字典变量前，增加两个**

def demo(*args,**kwargs):
    print(args)
    print(kwargs)

# 元组变量/字典变量
gl_nums= (1,2,3)
gl_dict ={"age":18,"name":"小明"}

demo(gl_nums,gl_dict) # 这样是不行的
demo(*gl_nums,**gl_dict) # 推荐

闭包函数

• 函数里面再定义函数
• 内部函数使用了外部函数的变量（还包括外部函数的参数）
• 外部函数返回了内部函数

# 定义闭包函数的方式
def average_obj():
    list_obj = []
    def inner(money):
        list_obj.append(money)
        return sum(list_obj) / len(list_obj)
    return inner

average = average_obj()
print(average(6000))

# 如果不使用闭包 list_obj 就得为全局变量，才能达到业务需求
# 使用了闭包会让 list_obj 从全局变量转为局部变量，令外部无法随意修改，保障了业务的安全

匿名函数 （lambda）

• 匿名函数，又称 lambda 函数
• 用来表示内部仅包含 1 行表达式的函数
• 如下格式的函数体可以用lambda函数代替

def name([参数1 [,参数2,..参数n]]): 
    return 表达式

# 普通函数
def addition1(a, b):
    c = a + b
    return c

print(addition1(1, 2))

# 匿名函数
f = lambda a, b: a + b
print(f(1, 2))

# 多参数匿名函数
x = lambda a, b, c : a + b + c
print(x(5, 6, 2))