Python——函数/方法
1.函数
•所谓函数，就是把 具有独立功能的代码块 组织为一个小模块，在需要的时候调用；
•函数的使用包含两个步骤： 1.定义函数 —— 封装 独立的功能；2.调用函数 —— 享受 封装 的成果；
•函数的作用，在开发程序时，使用函数可以提高编写的效率以及代码的 重用
2.函数的参数：函数(参数)
2.1 函数参数的使用
•在函数名的后面的小括号内部填写 参数
•多个参数之间使用 , 分隔
例如：sum_2_num(num1, num2)
参数带冒号：
在Python 中，函数参数可以带有冒号来指定参数的数据类型和默认值。带冒号的参数语法如下所示：
def function_name(param1:type=default_value,param2:type=default_value,
param3:type=default_value,...):
#函数体在上述语法中，function_name是函数的名称，para1、para2是函数的参数名称，type是参数的数据类型，default_value是参数的默认值。通过这种方式，我们可以在函数定义中明确参数的类型和默认值，以提高代码的可读性和可维护性。
def add(x:int,y:int=0):
return x+y在上述示例代码中，add是函数的名称，x和y是函数的参数名称，int是参数的数据类型，0是y参数的默认值。函数的返回类型被指定为int。
Python传参driver: WebDriver
def __init__(self, driver:WebDriver):
driver:WebDriver：指type() of driver是WebDriver。不影响运行。
_driver是driver:WebDriver的一个实例（instance）
2.2参数的作用
函数的参数，增加函数的 通用性，针对 相同的数据处理逻辑，能够 适应更多的数据
①.在函数 内部，把参数当做 变量 使用，进行需要的数据处理
②.函数调用时，按照函数定义的参数顺序，把 希望在函数内部处理的数据，通过参数 传递
2.3形参与实参
形参（形式上的参数），定义 函数时，小括号中的参数，是用来接收参数用的，在函数内部 作为变量使用
实参（实际要用的参数），调用 函数时，小括号中的参数，是用来把数据传递到 函数内部 用的
可混合使用位置实参、关键字实参和默认值实参。
①位置实参(实参顺序很重要)
def pet(animal_type,pet_name):
snip
pet('dog','lucky')
②关键字实参
关键字实参是传递给函数的名称-值对，直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆。不用考虑函数调用的实参顺序。
def pet(animal_type,pet_name):
snip
pet(animal_type='dog',pet_name='lucky')
③默认值实参
•定义函数时，可以给 某个参数 指定一个默认值，具有默认值的参数就叫做 缺省参数（默认值实参）
•调用函数时，如果没有传入 缺省参数 的值，则在函数内部使用定义函数时指定的 参数默认值；如果给形参提供了实参时，则使用指定的实参值
•函数的缺省参数，将常见的值设置为参数的缺省值，从而 简化函数的调用
例如：
def pet(pet_name，animal_type='dog'):
snip
pet(pet_name='lucky')
注意事项：
1) 缺省参数的定义位置
•必须保证 带有默认值的缺省参数在参数列表末尾
2) 调用带有多个缺省参数（默认值实参）的函数
•在 调用函数时，如果有 多个缺省参数，需要指定参数名，这样解释器才能够知道参数的对应关系
2.4不可变和可变的参数
可变类型参数：列表_list, 字典_dict、set
不可变类型参数：数字型（int,bool,float,complex,long）、字符串、元组、日期
问题 1：在函数内部，针对参数使用 赋值语句，会不会影响调用函数时传递的 实参变量？
—— 不会！无论传递的参数是 可变 还是 不可变 ，只要 针对参数 使用 赋值语句，会在 函数内部 修改 局部变量的引用，不会影响到 外部变量的引用。
def demo (num, num_list) :
num = 200
num_list = [1,2,3]
print(num)
print(num_list)
demo(10,[5,6])
#输出结果：
200
[1, 2, 3] 问题 2：如果传递的参数是 可变类型，在函数内部，使用 方法 修改了数据的内容，同样会影响到外部的数据
def demo2 (num_list):
num_list.extend([1,2,3])
print(num_list)
demo2([11,22])
#输出结果：[11, 22, 1, 2, 3]2.5传递列表
参数为列表：
'''向列表的每位用户发出简单的问候'''
def greet_users(names):
for name in names:
msg = "Hello, " + name.title() + "!"
print(msg)
usernames = ['hannah','ty','margot']
greet_users(usernames)
'''输出：
Hello, Hannah!
Hello, Ty!
Hello, Margot!
'''在函数中修改列表：
在函数中对这个列表所做的任何修改都是永久性的。
原函数：
'''打印设计好的模型：模拟打印每个设计，直到没有未打印的设计为止'''
unprinted_designs = ['iphone case','robot pendant','dodecahedron']
completed_models = []
while unprinted_designs:
current_design = unprinted_designs.pop()
print("Printting model: " + current_design)
completed_models.append(current_design)
print("\nThe following models have been printed:")
for completed_model in completed_models:
print(completed_model)
'''
Printting model: dodecahedron
Printting model: robot pendant
Printting model: iphone case
The following models have been printed:
dodecahedron
robot pendant
iphone case
'''改造成函数：
def print_models(unprinted_designs,completed_models):
while unprinted_designs:
current_design = unprinted_designs.pop()
print("Printting model: " + current_design)
completed_models.append(current_design)
def show_completed_models(completed_models):
print("\nThe following models have been printed:")
for completed_model in completed_models:
print(completed_model)
unprinted_designs = ['iphone case','robot pendant','dodecahedron']
completed_models = []
print_models(unprinted_designs,completed_models)
show_completed_models(completed_models)
'''
Printting model: dodecahedron
Printting model: robot pendant
Printting model: iphone case
The following models have been printed:
dodecahedron
robot pendant
iphone case
[]
'''禁止函数修改列表：
有时候，需要禁止修改函数列表。你如上述例子，即便打印所有设计后，也要保留原来未打印的设计列表，以供备案。
解决方案：可向函数传递列表的副本而不是原件。function_name(list_name[:])，切片表示法[:]创建列表的副本。
def print_models(unprinted_designs,completed_models):
while unprinted_designs:
current_design = unprinted_designs.pop()
print("Printting model: " + current_design)
completed_models.append(current_design)
def show_completed_models(completed_models):
print("\nThe following models have been printed:")
for completed_model in completed_models:
print(completed_model)
unprinted_designs = ['iphone case','robot pendant','dodecahedron']
completed_models = []
print_models(unprinted_designs[:],completed_models)
show_completed_models(completed_models)
print(unprinted_designs)
'''
Printting model: dodecahedron
Printting model: robot pendant
Printting model: iphone case
The following models have been printed:
dodecahedron
robot pendant
iphone case
['iphone case', 'robot pendant', 'dodecahedron']
''2.6多值参数
定义 支持多值参数 的函数：
•有时可能需要一个函数能够处理的参数 个数 是不确定的，这个时候，就可以使用多值参数，Python允许函数从调用语句中收集任意数量的实参。
•python 中有 两种 多值参数： ◦参数名前增加 一个* 可以接收 元组
◦参数名前增加 两个* 可以接收 字典
•一般在给多值参数命名时，习惯使用以下两个名字
*args（args 是 arguments 的缩写，有变量的含义） —— 存放 元组 参数，前面有一个 *
**kwargs（kw 是 keyword 的缩写，kwargs 可以记忆 键值对参数） —— 存放 字典 参数，前面有两个 *
Python当中，如果我们想让一个函数接收任何参数的话，我们可以写成:
def func(*args,**kw):
pass
其中arg其实代表一个数组，kmv代表一个dict，*args代表解压数组，**kw，也是将作为dict的kw解压，以key value的形式展开。不过如果你直接调用*kw会得到一个报错，这个操作只能在函数传递参数的时候使用。*args和*kw能够代表所有参数--因为前者代表了直接传递的必选参数，后者呢，代表提供了默认值的默认参数。这也是为什么python限定了默认参数必须放在必选参数后面的原因，一方面是为了消除歧义，另一方面也是为了能够用*args,*kw来统一表示。
案例：计算任意多个数字的和：
def sum_numbers(*args):
num = 0
# 遍历 args 元组顺序求和
for n in args:
num += n
return num
print(sum_numbers(1, 2, 3)) #结果：6'''创建一个字典，包含我们知道的有关用户的一切'''
def build_profile(first,last,**user_info):
profile = {}
profile['first_name'] = first
profile['last_name'] = last
for key,value in user_info.items():
profile[key] = value
return profile
user_profile = build_profile('albert','einstein',location='princeton',field = 'physics')
print(user_profile) #{'field': 'physics', 'first_name': 'albert', 'last_name': 'einstein', 'location': 'princeton'}元组和字典的拆包：
•在调用带有多值参数的函数时，如果希望： ◦将一个 元组变量，直接传递给 args
◦将一个 字典变量，直接传递给 kwargs
•就可以使用 拆包，简化参数的传递，拆包 的方式是： ◦在 元组变量前，增加 一个 *
◦在 字典变量前，增加 两个 *
def demo(*args, **kwargs):
print(args)
print(kwargs)
gl_nums = (1, 2, 3)
gl_dict = {"name": "小明", "age": 18}
demo(*gl_nums, **gl_dict)
'''结果
(1, 2, 3)
{'name': '小明', 'age': 18}
'''如果调用函数变量前不使用星号：
def demo(*args, **kwargs):
print(args)
print(kwargs)
gl_nums = (1, 2, 3)
gl_dict = {"name": "小明", "age": 18}
demo(gl_nums, gl_dict)
'''结果
((1, 2, 3), {'age': 18, 'name': '小明'})
{}
'''3.函数的返回值
•在程序开发中，有时候会希望一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理
•返回值 是函数完成工作后，最后给调用者的 一个结果
•在函数中使用 return 关键字可以返回结果
•调用函数一方，可以使用变量来接收函数的返回结果
注意：return 表示返回，后续的代码都不会被执行
（1）返回简单值
举例:
"""对两个数字的求和"""
def sum_2_num(num1, num2):
return num1 + num2
# 调用函数，并使用 result 变量接收计算结果
result = sum_2_num(10, 20)
print("计算结果是 %d" % result) #计算结果是 30（2）让实参变为可选的
有时候需要让实参变为可选的，这样调用函数时只需在必要时才提供额外的信息，可使用默认值来让实参变成可选的。
举例：get_formatted_name()
def get_formatted_name(first_name,middle_name,last_name):
full_name = first_name + ' ' + middle_name + ' ' + last_name
return full_name
musician = get_formatted_name('John','Lee','Hooker')
print(musician) #John Lee Hooker然而并非所有人都有中间名，如果只提供名和姓，该函数不能正常运行。改造：
def get_formatted_name(first_name,last_name,middle_name=''):
if middle_name:
full_name = first_name + ' ' + middle_name + ' ' + last_name
else:
full_name = first_name + ' ' + last_name
return full_name
musician = get_formatted_name('John','Lee','Hooker')
print(musician) #John Lee Hooker
dancer = get_formatted_name('Jimmy','Hendrix')
print(dancer) #Jimmy Hendrix（3）返回字典
函数可返回任何类型的值，包括列表和字典等复杂的数据结构。
def build_person(first_name,last_name,age=''):
person = {'first':first_name,'last':last_name}
if age:
person['age'] = age
return person
musician = build_person('Jimi','Hendrix')
print(musician) #{'last': 'Hendrix', 'first': 'Jimi'}
musician = build_person('Jimi','Hendrix',age=27)
print(musician) #{'first': 'Jimi', 'age': 27, 'last': 'Hendrix'}函数参数和返回值的作用
定义函数时，是否接收参数，或者是否返回结果，是根据 实际的功能需求 来决定的
1.如果函数 内部处理的数据不确定，就可以将外界的数据以参数传递到函数内部
2.如果希望一个函数 执行完成后，向外界汇报执行结果，就可以增加函数的返回值
4.函数的嵌套调用
一个函数里面又调用了另外一个函数，这就是 函数嵌套调用。
函数的递归：一个函数 内部 调用自己
◦函数内部可以调用其他函数，当然在函数内部也可以调用自己
代码特点
1.函数内部的 代码 是相同的，只是针对 参数 不同，处理的结果不同
2.当参数满足一个条件 时，函数不再执行
•这个非常重要，通常被称为递归的出口，否则 会出现死循环！
def f(x):
if x > 0:
return x + f(x - 1)
else:
return 0
print(f(100)) # 50505.使用模块中的函数
模块是 Python 程序架构的一个核心概念
•模块 就好比是 工具包，要想使用这个工具包中的工具，就需要 导入( import) 这个模块
•每一个以扩展名 .py 结尾的 Python 源代码文件都是一个 模块
•在模块中定义的 全局变量 、函数 都是模块能够提供给外界直接使用的工具
模块可以让 曾经编写过的代码方便的被 复用！
•可以 在一个 Python 文件 中 定义 变量 或者 函数
•然后在 另外一个文件中 使用 import 导入这个模块
•导入之后，就可以使用 模块名.变量 / 模块名.函数 的方式，使用这个模块中定义的变量或者函数
将函数存储在模块中
import 模块名字
import 模块名字 as 简略名字
#导入模块中的所有函数
from 模块名字 import *
#导入特定函数
from 模块名字 import 函数名字
6.方法：对象.方法名(参数)
•方法 和函数类似，同样是封装了独立的功能
•方法 需要通过 对象 来调用，表示针对这个 对象 要做的操作
7.闭包（Closure）
闭包
闭包的构成：
- 嵌套函数（函数内部定义的函数）。
- 嵌套函数引用了外部函数的变量。
- 外部函数返回嵌套函数，且该嵌套函数可以在其外部被调用。
def test1():
print("--- in test1 func----")
# 调⽤函数
test1()
# 引⽤函数
ret = test1
print(id(ret))
print(id(test1))
#通过引⽤调⽤函数
ret()# 定义⼀个函数
def test(number):
# 在函数内部再定义⼀个函数，并且这个函数⽤到了外边函数的变量，那么将这个函数以及⽤到的⼀些变量称之为闭包
def test_in(number_in):
print("in test_in 函数, number_in is %d" % number_in)
return number+number_in
# 其实这⾥返回的就是闭包的结果
return test_in
# 给test函数赋值，这个20就是给参数number
ret = test(20)
# 注意这⾥的100其实给参数number_in
print(ret(100))
#注 意这⾥的200其实给参数number_in
print(ret(200))def line_conf(a, b):
def line(x):
return a*x + b
return line
line1 = line_conf(1, 1)
line2 = line_conf(4, 5)
print(line1(5))
print(line2(5))运行结果：
6
25
为什么要使用nonlocal？
使用nonlocal可以帮助我们：
- 实现一些高级的功能，比如闭包，装饰器，生成器等
- 保持外层函数的局部变量的状态，避免使用全局变量或类属性等
- 提高代码的封装性和可读性，避免命名冲突和污染全局命名空间
如何使用nonlocal？nonlocal的基本语法如下：
def 外层函数():
# 定义一个外层函数的局部变量
变量 = 值
def 嵌套函数():
# 使用nonlocal关键字声明要修改的外层函数的局部变量
nonlocal 变量
# 修改外层函数的局部变量
变量 = 新值
# 调用嵌套函数
嵌套函数()
# 返回外层函数的局部变量
return 变量
外层函数：是一个定义了一个局部变量的函数，它也定义了一个嵌套函数，用于修改这个局部变量
嵌套函数：是一个在外层函数内部定义的另一个函数，它使用nonlocal关键字声明要修改的外层函数的局部变量，然后对其进行修改
nonlocal：是一个关键字，用于在嵌套函数中修改外层函数的局部变量，它后面跟着要修改的变量的名称，可以有多个，用逗号分隔。
举个例子
假设我们要定义一个函数，用于生成一个计数器，每次调用时返回一个递增的整数。我们可以使用nonlocal来实现这个功能，代码如下：
# 定义一个函数，用于生成一个计数器
def counter():
# 定义一个外层函数的局部变量，用于存储计数值，初始为0
count = 0
# 定义一个嵌套函数，用于返回并修改计数值
def next():
# 使用nonlocal关键字声明要修改的外层函数的局部变量
nonlocal count
# 将计数值加1
count += 1
# 返回计数值
return count
# 返回嵌套函数
return next
我们可以在其他地方调用这个函数，比如：
# 调用counter函数，得到一个计数器
c = counter()
# 打印计数器的返回值
print(c()) # 输出1
print(c()) # 输出2
print(c()) # 输出3python3的⽅法：
def counter(start=0):
def incr():
nonlocal start
start += 1
return start
return incr
c1 = counter(5)
print(c1())
print(c1())
c2 = counter(50)
print(c2())
print(c2())
print(c1())
print(c1())
print(c2())
print(c2())运行结果：
6
7
51
52
8
9
53
54
def counter(start=0):
count=[start]
def incr():
count[0] += 1
return count[0]
return incr
c1 = closeure.counter(5)
print(c1()) # 6
print(c1()) # 7
c2 = closeure.counter(100)
print(c2()) # 101
print(c2()) # 1028.常见方法
input()
输入函数input()，函数等待用户在键盘上输入一些文本，并按下回车键，这个函数求值为一个字符串，即用户输入的文本。比如：myname = input()，你可以认为input()函数调用是一个表达式，它求值为用户输入的任何字符串。如果用户输入'Al'，那么该表达式就求值为myName = 'Al'。
print()
输出函数print()，1.向控制台输出内容结束之后，不会换行：print("*******", end="")；
end = ""，表示输出结束后，不换行
"\t" 可以在控制台输出一个制表符，协助在输出文本时对齐
print("%d * %d = %d" % (col, row, row * col), end="\t") # 用%表示前后对应
title = driver.title
print("title:"+ title)#或者print("title:",title)def pet(animal_type, pet_name):
print("It's a " + animal_type + ",and it's name is " + pet_name) # It's a dog,and it's name is lucky
print("It's a %s,and it's name is %s" % (animal_type,pet_name)) #It's a dog,and it's name is lucky
pet('dog', 'lucky')
int()
class int(x, base=10)- x -- 字符串或数字。
- base -- 进制数，默认十进制。
len()
len()函数，你可以向len()函数传递一个字符串（或包含字符串的变量），然后该函数求值为一个整型值，即字符串中字符的个数。
split()
string.split(str="", num) 以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个子字符串，str 默认包含 '\r', '\t', '\n' 和空格。
num -- 分割次数。默认为 -1, 即分隔所有。
str = "Line1-abcdef \nLine2-abc \nLine4-abcd"
print(str.split( )) # 以空格为分隔符，包含 \n
print(str.split(' ', 1 ))# 以空格为分隔符，分隔成两个结果：
['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
['Line1-abcdef', '\nLine2-abc \nLine4-abcd']
eval()
评估函数eval()，去掉参数最外侧引号并执行剩下的语句
format()
{ }.format( )，{ }表示槽，后续format里面的变量填充到槽里
>>>"{} {}".format("hello", "world") # 不设置指定位置，按默认顺序 'hello world'
>>> "{0} {1}".format("hello", "world") # 设置指定位置 'hello world'
>>> "{1} {0} {1}".format("hello", "world") # 设置指定位置 'world hello world'
round()
round()，通常让小数精确到小数点后多少位，其中小数位数是由第二个实参指定的。如果将第二个实参指定为负数，round()将圆整到最近的10,100,1000等整数倍。
round(number,digits)
- digits>0，四舍五入到指定的小数位
- digits=0, 四舍五入到最接近的整数
- digits<0 ，在小数点左侧进行四舍五入
- 如果round()函数只有number这个参数，等同于digits=0
四舍五入规则：
- 要求保留位数的后一位<=4，则舍去，如5.214保留小数点后两位，结果是5.21
- 要求保留位数的后一位“=5”，且该位数后面没有数字，则不进位，如5.215，结果为5.21(不一定？)
- 要求保留位数的最后一位“=5”，且该位数后面有数字，则进位，如5.2151，结果为5.22
- 要求保留位数的最后一位“>=6”，则进位。如5.216，结果为5.22
yield()
yield 的函数在 Python 中被称之为 generator（生成器）,不像一般的函数会生成值后退出，生成器函数在生成值后会自动挂起并暂停他们的执行和状态，他的本地变量将保存状态信息，这些信息在函数恢复时将再度有效。
为什么叫生成器函数？因为他随着时间的推移生成了一个数值队列。一般的函数在执行完毕之后会返回一个值然后退出，但是生成器函数会自动挂起，然后重新拾起继续执行，他会利用yield关键字关起函数，给调用者返回一个值，同时保留了当前的足够多的状态，可以使函数继续执行。生成器和迭代协议是密切相关的，可迭代的对象都有一个__next()__成员方法,这个方法要么返回迭代的下一项，要么引起异常结束迭代。为了支持迭代协议，拥有yield语句的函数被编译为生成器，这类函数被调用时返回一个生成器对象，返回的对象支持迭代接口，即成员方法__next()__继续从中断处执行执行。
def myfun(total):
for i in range(total):
yield i生成器有3种调用方式：
①用next调用
>>> m = myfun(4)
>>> next(m)
0
>>> next(m)
1
>>> next(m)
2
>>> next(m)
3
>>> next(m)
Traceback (most recent call last):
File "", line 1, in
StopIteration ②循环调用
for i in myfun(4):
print(i)③循环中调用next
>>> m = myfun(4)
>>> while True:
... try:
... print(next(m))
... except StopIteration:
... breakrange()
函数原型：range（start， end， scan):
参数含义：
- start:计数从start开始。默认是从0开始。例如range（5）等价于range（0， 5）;
- end:计数到end结束，但不包括end.例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
- scan：每次跳跃的间距，默认为1，且step可正可负，但不能为0。例如：range(3,100,25)，结果是3,28,53,78
range() 函数返回的结果是一个整数序列的对象。
另：
a = int(input())
#range(a)就是range(你输入的数)
for i in range(a):li = ["alec", " aric", "Alex", "Tony", "rain"]
tu = ("alec", " aric", "Alex", "Tony", "rain")
dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}
for a in range(len(li)):
pass
print(li) # ['alec', ' aric', 'Alex', 'Tony', 'rain']
for b in range(len(tu)):
pass
print(tu) #('alec', ' aric', 'Alex', 'Tony', 'rain')
for c in dic:
pass
print(dic) #{'k1': 'alex', 'k2': ' aric', 'k3': 'Alex', 'k4': 'Tony'}for i in range(10, -6, -2):
print(i)
'''
结果：
10
8
6
4
2
0
-2
-4
'''count()
count() 方法用于统计字符串里某个字符出现的次数
语法：str.count(sub, start=0,end=len(string))
- sub -- 搜索的子字符串
- start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
- end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
str = "this is string example....wow!!!"
sub = "i"
print("str.count(sub, 4, 40) : ", str.count(sub, 4, 40))结果：str.count(sub, 4, 40) : 2
List count()
返回元素在列表中出现的次数。
list.count(obj) #obj -- 列表中统计的对象。必需。任何类型（字符串、数字、列表、元组等）。要搜索的值。aList = [123, 'xyz', 'zara', 'abc', 123];
print ("Count for 123 : ", aList.count(123))
print ("Count for zara : ", aList.count('zara'))结果：
Count for 123 : 2
Count for zara : 1
max()
max() 方法返回给定参数的最大值，或者 iterable（可迭代对象，包含一个或多个供比较的项目） 中有最大值的项目。如果值是字符串，则按字母顺序进行比较
语法：
max(iterable, *[, key, default])
max(arg1, arg2, *args[, key]) #命名参数key，其为一个函数，用来指定取最大值的方法（key 实参指定排序函数用的参数）。default命名参数用来指定最大值不存在时返回的默认值。
和其他稳定排序工具如 sorted(iterable, key=keyfunc, reverse=True)一致。
- 默认数值型参数，取值大者；
- 当存在多个相同的最大值时，返回的是最先出现的那个最大值
- 字符型参数，取字母表排序靠后者；
- 序列型参数，则依次按索引位置的值进行比较取最大者。
- 还可以通过传入命名参数key，指定取最大值方法。
举例：
#传入的多个参数的最大值
print(max(80, 100, 1000)) #1000
#传入可迭代对象时，取其元素最大值
a = '12345'
print(max(a)) #5
a='1,2,3,4'
print(type(a)) #
print(max(a)) #4
a=[1,2,3,4]
print(type(a)) #
print(max(a)) #4
# #列表里面的元素都由元组构成，元组都由数字组成，输出最大值
a=[(1,2),(2,3),(3,4)]
print(max(a)) #(3, 4)
#因为ascii 码里面，按照排列顺序 小 a在 A的后面
a=[('a',1),('A',1)]
print(max(a)) #('a', 1)
#比较字典里面的最大值，会输出最大的键值
a={1:2,2:2,3:1,4:'aa'}
print(max(a)) #4
#传入可迭代对象为空时，必须指定参数default，用来返回默认值输出。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError
print(max((),default=1)) #1
#传入命名参数key，其为一个函数，用来指定取最大值的方法
a = [
{'name': 'sumcet', 'age': 18},
{'name': 'bbu', 'age': 11}]
print(max(a, key=lambda x: x['age'])) #{'age': 18, 'name': 'sumcet'}
#key参数的另外一个作用是，不同类型对象本来不能比较取最大值的，传入适当的key函数，变得可以比较能取最大值了。
print(max(1,2,'3',key = int)) #3
print(max(-1,0,key = abs)) # -1 当传入参数为数据类型不一致时，传入的所有参数将进行隐式数据类型转换后再比较，如果不能进行隐式数据类型转换，则会报错：
>>> max(1,1.1,1.3E1)
13.0
>>> max(1,2,3,'3')
Traceback (most recent call last):
File "", line 1, in
max(1,2,3,'3')
TypeError: unorderable types: str() > int()
>>> max([1,2],(1,3))
Traceback (most recent call last):
File "", line 1, in
max([1,2],(1,3))
TypeError: unorderable types: tuple() > list() join()
str.join(sequence):用于将序列中的元素以指定的字符连接生成一个新的字符串str = "-";
seq = ("a", "b", "c"); # 字符串序列
print str.join( seq );结果：a-b-c
ctime()
Python time ctime() 函数把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。 如果参数未给或者为None的时候，将会默认time.time()为参数。它的作用相当于 asctime(localtime(secs))。
from time import ctime
print("time is %s" % ctime())