时间：2022-12-04 12:55:27 | 栏目：Python代码 | 点击：次
函数先定义函数，后调用
Python 定义函数使用 def 关键字
默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。
def 函数名(param1,param2……): """ 函数功能的描述信息 :param1：描述 :param2：描述 :return：返回值 """ code ... return 返回值
def register():
"""注册功能"""
username = input('username: ').strip()
pwd = input('password: ').strip()
with open('32.txt', 'a', encoding='utf8') as fa:
fa.write(f"{username}:{pwd}\n")
fa.flush()
def sum_self(x, y):
"""求和"""
res = x+y
print(res)
sum_self(1,2) # 3
你只知道你需要实现某个功能，但不知道该如何用代码实现时，你可以暂时写个空函数
def func():
pass
定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。
函数名(param1、param2……)
如：
register()
def foo():
pass
print(foo()) #None
def func():
name = 'nick'
age = 19
hobby_list = ['read', 'run']
return name, age, hobby_list
name, age, hobby_list = func()
print(name,age,hobby_list) #('nick', 19, ['read', 'run'])
在函数定义阶段，按照从左到右的顺序依次定义的形参，称之为位置形参。
特点：按照位置定义的形参，都必须被传值，多一个不行，少一个也不行。
def func(x, y):
print(x)
print(y)
在函数调用阶段，按照从左到右的顺序依次定义的实参，称之为位置实参。
特点：按照位置为对应的形参依次传值。
func(1, 2)
在调用函数时，按照key=value的形式为指定的参数传值，称为关键字实参。
特点：可以打破位置的限制，但仍能为指定的形参赋值。
func(y=2, x=1)
func(x, y=2) func(y=2, x) # SyntaxError: positional argument follows keyword argument func(x, x=1) # NameError: name 'x' is not defined
在定义阶段，就已经被赋值。意味着在调用时可以不用为其赋值。位置形参必须放在默认形参的左边。
def func(x, y=10):
print(x)
print(y)
func(2)
默认形参的值只在定义阶段赋值一次，也就是说默认参数的值在函数定义阶段就已经固定了。
m = 10
def foo(x=m):
print(x)
m = 111
foo() # 10
默认参数的值通常应该是不可变类型。
def register(name, hobby, hobby_list=None):
hobby_list = [hobby]
print(f"{name} prefer {hobby_list}")
register('nick', 'read') # ['read']
register('tank', 'zuipao') # [ 'zuipao']
register('jason', 'piao') # ['piao']
# 演示形参是可变类型,（列表是可变类型）
def register(name, hobby, hobby_list=None):
hobby_list = [hobby]
print(f"{name} prefer {hobby_list}")
register('nick', 'read') # nick prefer ['read']
register('tank', 'zuipao') # tank prefer ['zuipao']
register('jason', 'piao') # jason prefer ['piao']o']
形参中的*会将溢出的位置实参全部接收，然后存储元组的形式，然后把元组赋值给*后的参数。需要注意的是：*后的参数名约定俗成为args。
def sum_self( *args):
res = 0
for num in args:
res += num
return res
res = sum_self(1, 2, 3, 4)
print(res) # 10
实参中的*，*会将*后参数的值循环取出，打散成位置实参。以后但凡碰到实参中带*的，它就是位置实参，应该马上打散成位置实参去看。
def func(x, y, z, *args):
print(x, y, z, args)
func(1, *(1, 2) , 3, 4) # 1 1 2 (3, 4)
形参中的**会将溢出的关键字实参全部接收，然后存储字典的形式，然后把字典赋值给**后的参数。需要注意的是：**后的参数名约定俗成为kwargs。
def func( **kwargw):
print(kwargw)
func(a=5,b=3) # {'a': 5, 'b': 3}
实参中的**，**会将**后参数的值循环取出，打散成关键字实参。以后但凡碰到实参中带**的，它就是关键字实参，应该马上打散成关键字实参去看。
def func(x, y, z, **kwargs):
print(x, y, z, kwargs)
func(1, 3, 4, **{'a': 1, 'b': 2} ) # 1 3 4 {'a': 1, 'b': 2}
def index(name, age, sex):
print(f"name: {name}, age: {age}, sex: {sex}") # name: nick, age: 19, sex: male
def wrapper(*args, **kwargs):
print(f"args: {args}") # args: ()
print(f"kwargs: {kwargs}") # kwargs: {'name': 'nick', 'sex': 'male', 'age': 19}
index( *args, **kwargs)
wrapper(name='nick', sex='male', age=19)
命名关键字则是在「位置参数」和「命名关键字参数」中使用,*,隔开，后面的即为命名关键字。* 后的参数必须用关键字传入。
def student(name, age, *, city, gender):
print(name, age, city, gender)
student('xiaoming', 6, city='beijing', gender='male') # xiaoming 6 beijing male
student('xiaoming', 6, 'beijing', 'male') #TypeError: student() takes 2 positional arguments but 4 were given
特点：在传值时，必须按照key=value的方式传值，并且key必须命名关键字参数的指定的参数名。
def register(x, y, *, name, gender='male', age):
print(x)
print(name)
print(age)
register(1, 2, name1='nick', age=19) # TypeError: register() got an unexpected keyword argument 'name1'
Python3.8 新增了一个函数形参语法， “/” 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。
在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 或 f 要求为关键字形参:
def f(a, b, /, c, d, *, e, f):
print(a, b, c, d, e, f)
以下使用方法是正确的:
f(10, 20, 30, d=40, e=50, f=60)
函数是第一类对象，即函数可以被当做数据处理。
def func():
print('from func')
print(func) #
def func():
print('from func')
def foo(m):
m()
foo(func) # from func
def func():
print('from func')
def foo(x):
return x
res = foo(func)
print(res) #
def func():
print('from func')
function_list = [func]
function_list[0]() # from func
递归的精髓在于通过不断地重复逼近一个最终的结果。
age(1)=26,age(n)=age(n-1)+2 ，求age(5)的值：
'''
...
age(5) = age(4) + 2
age(4) = age(3) + 2
age(3) = age(2) + 2
age(2) = age(1) + 2
age(1) = 26
age(n) = age(n-1) +2
age(1) = 26 # n=1
'''
def age(n):
if n == 1:
return 26
res = age(n-1) + 2
return res
print(f"age(5): {age(5)}")
递归的本质就是干重复的活。
lis = [1, [2, [3, [4, [5, [6, ]]]]]]
def tell(lis):
for i in lis:
if type(i) is list:
tell(i)
else:
print(i)
tell(lis)
二分法的思想实现查找数字。
from random import randint
nums = [randint(1, 100) for i in range(100)]
nums = sorted(nums)
def search(search_num, nums):
print(nums)
mid_index = len(nums) // 2
if not nums:
print('not exists')
return
if search_num > nums[mid_index]:
# in the right
nums = nums[mid_index + 1:]
search(search_num, nums)
elif search_num < nums[mid_index]:
# in the left
nums = nums[:mid_index]
search(search_num, nums)
else:
print('find it')
search(7, nums)
python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
lamdbda 参数 : 逻辑代码
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
匿名函数，他没有绑定名字，使用一次即被收回，加括号既可以运行。
print(lambda x, y: x + y ) # (x, y)> res = (lambda x, y: x + y)(1, 2) print(res) # 3
lambda 匿名函数也是可以使用"关键字参数"进行参数传递,也可以设定默认值。
g = lambda x=0, y=0: x ** 2 + y ** 2 print(g(2, 3)) # 13 print(g(2)) # 4 print(g(y=3)) # 9
匿名函数通常与max()、sorted()、filter()、sorted()方法联用。
如果我们想从上述字典中取出薪资最高的人，我们可以使用max()方法，但是max()默认比较的是字典的key。
salary_dict = {
'nick': 3000,
'jason': 100000,
'tank': 5000,
'sean': 2000
}
print(max(salary_dict)) # tank
def func(k):
return salary_dict[k]
print(max(salary_dict, key=func)) # jason
print(max(salary_dict, key=lambda name: salary_dict[name] ) ) # jason 匿名函数
如果我们想对上述字典中的人，按照薪资从大到小排序，可以使用sorted()方法。
lis = [1, 3, 2, 5, 8, 6]
sorted(lis)
print(lis) # [1, 3, 2, 5, 8, 6]
print(sorted(lis, reverse=True)) # [8, 6, 5, 3, 2, 1]
salary_dict = {
'nick': 3000,
'jason': 100000,
'tank': 5000,
'sean': 2000
}
print(sorted(salary_dict, key=lambda name: salary_dict[name] )) # ['sean', 'nick', 'tank', 'jason']
如果我们想对一个列表中的某个人名做处理，可以使用map()方法。
name_list = ['jason', 'tank', 'sean']
res = map(lambda name: f"{name} sb", name_list)
print(list(res)) # ['jason sb', 'tank sb', 'sean sb']
如果我们想筛选除名字中含有'sb'的名字，我们可以使用filter()方法。
name_list = ['nick', 'jason sb', 'tank sb', 'sean sb']
filter_res = filter(lambda name: name.endswith('sb'), name_list)
print(list(filter_res)) # ['jason sb', 'tank sb', 'sean sb']
共68个：
abs()、 all()、 any()、 ascii()、 bin()、 bool()、 bytearray()、 bytes()、 callable()、 chr()、 classmethod()、 compile()、 complex()、 delattr()、
dict()、 dir()、 divmod()、 enumerate()、 eval()、 exec()、 filter()、 float()、 format()、 frozenset()、 getattr()、 globals()、 hasattr()、 hash()、
help()、 hex()、 id()、 input()、 int()、 isinstance()、 issubclass()、 iter()、 len()、 list()、 locals()、 map()、 max()、 memoryview()、
min()、 next()、 object()、 oct()、 open()、 ord()、 pow()、 print()、 property()、 range()、 repr()、 reversed()、 round()、 set()、
setattr()、 slice()、 sorted()、 staticmethod()、 str()、 sum()、 super()、 tuple()、 type()、 vars()、 zip()、 __import__()、
res = '你好'.encode('utf8')
print(res) # b'\xe4\xbd\xa0\xe5\xa5\xbd'
res = bytes('你好', encoding='utf8')
print(res) # b'\xe4\xbd\xa0\xe5\xa5\xbd'
print(chr(65)) #A
print(ord('A')) #65
print(divmod(10, 3)) #(3, 1)
l = ['a', 'b', 'c']
for i in enumerate(l):
print(i)
# (0, 'a')
# (1, 'b')
# (2, 'c')
lis = '[1,2,3]' lis_eval = eval(lis) print(lis_eval) #[1, 2, 3]
print(hash(1)) #1
print(abs(-13)) # 13
print(all([1, 2, 3, 0])) #False print(all([])) #True
print(any([1, 2, 3, 0])) #True print(any([])) #False
print(bin(17)) #0b10001 print(oct(17)) #0o21 print(hex(17)) #0x11
import time print(dir(time)) # ['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'clock', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'perf_counter', 'process_time', 'sleep', 'strftime', 'strptime', 'struct_time', 'time', 'timezone', 'tzname', 'tzset']
s = frozenset({1, 2, 3})
print(s) #({1, 2, 3})
# print(globals())
def func():
a = 1
# print(globals())
print(locals())
func() # {'a': 1}
print(pow(3, 2, 3)) # (3**2)%3 =0
print(round(3.5)) #4
lis = ['a', 'b', 'c'] s = slice(1, 4, 1) print(lis[s]) #['b', 'c'] # print(lis[1:4:1])
print(sum(range(100))) #4950
m = __import__('time')
print(m.time()) #1556607502.334777