《疯狂Python讲义》读书笔记——第5章 函数和Lambda表达式

最新推荐文章于 2024-04-16 17:07:29 发布
最新推荐文章于 2024-04-16 17:07:29 发布
阅读量891 收藏 4
点赞数
分类专栏： Python语言 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wscwyr/article/details/90228960
版权

本章要点：

  • 函数的语法和调用函数
  • 函数返回多个值
  • 递归函数
  • 关键字参数
  • 为形参指定默认值
  • 参数收集（形参个数可变的函数）
  • 逆向参数收集（调用函数时序列解包）
  • 参数传递机制
  • 变量作用域，以及访问不同作用域变量的方法
  • 局部函数的用法
  • 将函数当成对象用于赋值
  • 将函数作为参数或返回值
  • lambda表达式的基本用法
  • 使用lambda表达式代替局部函数

目录

5.1 函数入门

5.1.2 理解函数

5.1.2 定义函数和调用函数

5.1.3 为函数提供文档

5.1.4 多个返回值

5.1.5 递归函数

5.2 函数的参数

5.2.1 关键字（keyword）参数

5.2.2 参数默认值

5.2.3 参数收集（个数可变的参数）

5.2.4 逆向参数收集

5.2.5 函数的参数传递机制

5.2.6 变量的作用域

5.3 局部函数

5.4 函数的高级内容

5.4.1 使用函数作为变量

5.4.2 使用函数作为函数形参

5.4.3 使用函数作为返回值

5.5 局部函数与lambda表达式

5.5.1 回顾局部函数

5.5.2 使用lambda表达式替代局部函数

5.1 函数入门

5.1.2 理解函数

函数是Python程序的重要组成单位，一个Python程序可以由很多个函数组成。

函数可以接受0个或多个参数，返回0个或多个值。

函数调用示意图

5.1.2 定义函数和调用函数

定义函数语法：

def 函数名(形参列表) :
    //有零个到多条可执行语句组成的函数
    [return [返回值]]

例如：

#*****************************
#***程序名称：function_test.py
#***程序功能：定义两个函数
#***编写日期：2019-5-16		
#*****************************
#定义一个函数，声明两个形参
def my_max(x,y):
	#定义一个变量z，该变量等于x，y中较大的值
	z = x if x > y else y
	#返回变量z
	return z
#定义一个函数，声明一个形参
def say_hi(name):
	print("====正在执行say_hi()函数====")
	return name + "，你好！"
a = 6
b = 9
#调用my_max()函数，将函数返回值赋值给result变量
result = my_max(a,b)
print("result:",result)
#调用say_hi()函数，直接输出函数的返回值
print(say_hi("孙悟空"))

5.1.3 为函数提供文档

一共两种方式：

（1）通过help()函数查看函数的说明文档；

（2）通过函数的__doc__属性访问函数的说明文档。（注意doc前后各是两个英文"_"）

例如：

#*****************************
#***程序名称：function_doc.py
#***程序功能：为函数编写说明文档
#***编写日期：2019-5-16		
#*****************************
def my_max(x,y):
	'''
	获取两个数值之间较大数的函数

	my_max(x,y)
		返回x，y两个参数之间较大的那个数
	'''
	#定义一个变量z，该变量等于x，y中较大的值
	z = x if x > y else y
	#返回变量z
	return z
#使用help()函数查看my_max()的帮助文档
help(my_max)
#__doc__两边一定要是双下划线，否则报错！（_doc_这是错的！）
print(my_max.__doc__)

5.1.4 多个返回值

如果程序需要多个返回值，则即可将多个值包装成列表之后返回，也可直接返回多个值。如果返回多个值，Python会自动将多个返回值封装成元组。

例如：

#*****************************
#***程序名称：multi_return.py
#***程序功能：函数直接返回多个值的情形
#***编写日期：2019-5-16		
#*****************************
def sum_and_avg(list):
	sum = 0
	count = 0
	for e in list:
		#如果元素e是数值
		if isinstance(e,int) or isinstance(e,float):
			count += 1
			sum += e
	return sum , sum / count
my_list = [20,15,2.8,'a',35,5.9,-1.8]
#获取sum_and_avg函数返回的多个值，多个返回值被封装成元组
tp = sum_and_avg(my_list)
print(tp)
#使用序列解包来获取多个返回值
s , avg = sum_and_avg(my_list)
print(s)
print(avg)

5.1.5 递归函数

定义：在一个函数体内调用它自身，被称为函数递归。

函数递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。

注意：递归一定要向已知方向进行。

例如：

#*****************************
#***程序名称：recursive.py
#***程序功能：已知有一个数列：f(0)=1,f(1)=4,f(n+2)=2*f(n+1)+f(n),
#其中n是大于0的整数，求f(10)的值。
#***编写日期：2019-5-16		
#*****************************
def fn(n):
	if n == 0 :
		return 1
	elif n == 1 :
		return 4
	else :
		#在函数体中调用它自身，就是函数递归
		return 2 * fn(n-1) + fn(n-2)
#输出fn(10)的结果
print("fn(10)的结果是：",fn(10))

5.2 函数的参数

——谁调用函数，谁负责传入参数。

5.2.1 关键字（keyword）参数

（1）位置参数——按照位置传入的参数。

（2）关键字参数——根据参数名传入的参数值。在关键字参数之后的只能是关键字参数。关键字参数必须位于位置参数后面。

例如：

#*****************************
#***程序名称：named_param_test.py
#***程序功能：函数的参数
#***编写日期：2019-5-16		
#*****************************
#定义一个函数
def girth(width,height):
	print("width:",width)
	print("height:",height)
	return 2 * (width + height)
#传统调用函数的方式，根据位置传入参数值
print(girth(3.5,4.8))
print("----------------------")
#根据关键字参数传入参数值
print(girth(width = 3.5,height = 4.8))
print("----------------------")
#使用关键字参数时可以交换位置
print(girth(height = 4.8,width = 3.5))
print("----------------------")
#部分使用关键字参数，部分使用位置参数
print(girth(3.5,height = 4.8))

5.2.2 参数默认值

语法格式：

形参名 = 默认值

注意：Python要求将带默认值的参数定义在形参列表的最后。

例如：

#*****************************
#***程序名称：default_param_test.py
#***程序功能：为函数的形参指定默认值
#***编写日期：2019-5-18		
#*****************************
#为两个参数指定默认值
def say_hi(name = "孙悟空",message = "欢迎来到疯狂软件"):
	print(name, "，你好！")
	print("消息是：",message)
#全部使用默认参数
say_hi()
print("---------------------------")
#只有message参数使用默认值
say_hi("白骨精")
print("---------------------------")
#两个参数都不使用默认值
say_hi("白骨精","欢迎学习Python")
print("---------------------------")
#只有name参数使用默认值
say_hi(message = "欢迎学习Python")

有例如：

#*****************************
#***程序名称：default_param_test2.py
#***程序功能：Python要求将带有默认值的
#参数（关键字参数）定义在形参列表的最后
#***编写日期：2019-5-18		
#*****************************
#定义一个打印三角形的函数，有默认值的参数必须放在后面
def printTriangle(char , height = 5):
	for i in range(1,height + 1 ):	#控制打印行数
		#先打印一排空格
		for j in range(height - i):
			print(' ', end = '')
		#在打印一排特殊字符
		for j in range(2 * i - 1):
			print(char , end = '')
		print()		#换行
printTriangle('@',  6)
printTriangle('#',  height = 7)
printTriangle(char = '*')

5.2.3 参数收集（个数可变的参数）

（1）在形参前面添加一个星号（*），该参数可接受多个参数值，并且被当成元组传入。

例如：

#*****************************
#***程序名称：varargs.py
#***程序功能：定义一个形参个数可变的函数
#***编写日期：2019-5-18		
#*****************************
#定义了支持参数收集的函数
def test(a , *books):
	print(books)
	#books被当成元组处理
	for b in books :
		print(b)
	#输出整数变量a的值
	print(a)
#调用test()函数
test(5 , "疯狂iOS讲义","疯狂Android讲义")

Python要求一个函数最多只能带一个支持“普通”参数收集的形参。

例如：

#*****************************
#***程序名称：varargs2.py
#***程序功能：Python要求一个函数最多只能带一个支持“普通”参数收集的形参
#***编写日期：2019-5-18		
#*****************************
#定义了支持参数收集的函数
def test(*books , num):
	print(books)
	#books被当成元组处理
	for b in books:
		print(b)
	print(num)
#调用test()函数
test("疯狂iOS讲义","疯狂Android讲义",num = 20)		#使用关键字参数

 

（2）Python还可以收集关键字参数，需要在参数前面添加两个星号（**）。

例如：

#*****************************
#***程序名称：varargs3.py
#***程序功能：Python还可以收集关键字参数，需要在参数前加**。
#Python会将这种关键字参数收集成字典。
#***编写日期：2019-5-18		
#*****************************
#定义了支持参数收集的函数
def test(x , y , z = 3 ,*books , **scores):
	print(x,y,z)
	print(books)
	print(scores)
test(1,2,3,"疯狂iOS讲义","疯狂Android讲义",语文=89,数学=94)
'''运行结果如下：
1 2 3
('疯狂iOS讲义', '疯狂Android讲义')
{'语文': 89, '数学': 94}
'''
print("--------------------------")
test(1,2,"疯狂iOS讲义","疯狂Android讲义",语文=89,数学=94)
print("--------------------------")
#让z参数的默认值发挥作用，books参数将是一个空元组
test(1,2,语文=89,数学=94)

5.2.4 逆向参数收集

定义：指的是在程序已有列表、元组、字典等对象的前提下，把它们的元素“拆开”后传给函数的参数。

注意：逆向参数收集需要在传入的列表、元组参数之前添加一个星号，在字典参数之前添加两个星号。

 

 

例如：

#*****************************
#***程序名称：varargs4.py
#***程序功能：逆向参数收集——指的是在程序已有列表、元组、字典等对象
#的前提下，把它们的元素“拆开”后传递给函数的参数。
#注意：列表、元组参数之前添加*，字典参数之前添加**
#***编写日期：2019-5-18		
#*****************************
def test(name , message):
	print("用户是：", name)
	print("欢迎信息是：",message)
my_list = ['孙悟空' , '欢迎来疯狂软件']
test(*my_list)
print("--------------------------")
def foo(name , *nums):
	print("name参数：",name)
	print("nums参数：",nums)
my_tuple = (1,2,3)
#使用逆向收集，将my_tuple元组的元素传给nums参数
foo('fkit' , *my_tuple)
print("--------------------------")
#使用逆向收集，将my_tuple元组的第一个元素传给name参数，剩下的元素传给nums参数
foo(*my_tuple)
print("--------------------------")
#不使用逆向收集，my_tuple元组整体传给name参数
foo(my_tuple)
print("--------------------------")
#字典使用逆向收集，会以关键字参数的形式传入
def bar(book , price , desc):
	print(book , "这本书的价格是：" , price)
	print('描述的信息是：' , desc)
my_dict = {'price': 89 , 'book': '《疯狂Python讲义》','desc' : '这是一本系统全面的Python学习图书。'}
#按逆向收集的方式将my_dict的多个key-value对传给bar()函数
bar(**my_dict)

5.2.5 函数的参数传递机制

——Python中函数的参数传递机制都是“值传递”。

值传递——就是将实际参数值的副本（复制品）传入函数，而参数本身不会受到任何影响。

例1：

#*****************************
#***程序名称：int_transfer_test.py
#***程序功能：函数的参数传递机制
#	值传递——就是将实际参数值得副本传入函数
#	而参数本身不会受到任何影响
#***编写日期：2019-5-18		
#*****************************
def swap(a , b):
	#下面代码实现a,b变量的值交换
	a,b = b,a
	print("在swap函数里，a的值是：", a , "——b的值是：",b)
a = 6
b = 9
swap(a ,b)
print("交换结束后，变量a的值是：",a,"——b的值是：",b)

例2：

#*****************************
#***程序名称：dict_transfer_test.py
#***程序功能：函数的参数传递机制
#	参数本身是一个可变对象（例如列表、字典等）
#	时，值得传递效果。
#***编写日期：2019-5-18		
#*****************************
def swap(dw):
	#下面代码实现dw的a,b两个元素的值交换
	dw['a'] , dw['b'] = dw['b'],dw['a']
	print("在swap函数里，a元素的值是：", dw['a'] , "——b元素的值是：",dw['b'])
dw = {'a':6, 'b':9}
swap(dw)
print("交换结束后，a元素的值是：", dw['a'], "——b元素的值是：", dw['b'])
'''执行代码的结果
在swap函数里，a元素的值是： 9 ——b元素的值是： 6
交换结束后，a元素的值是： 9 ——b元素的值是： 6
'''

5.2.6 变量的作用域

变量分为两种：

（1）局部变量：在函数中定义的变量（包括参数）。

（2）全局变量：在函数外面、全局范围内定义的变量。（可以在所有函数内被访问）

Python提供了三个工具函数来获取指定范围内的“变量字典”。

  • globals()：该函数返回全局范围所有变量组成的“变量字典”。
  • locals()：返回当前局部范围内所有变量组成的“变量字典”。
  • vars(object)：获取在指定对象范围内所有变量组成的“变量字典”。如果不传入object参数，它和locals()的作用完全相同。

下面的代码示范了如何使用locals()、globals()函数访问局部范围和全局范围内的“变量字典”。

#*****************************
#***程序名称：locals_test.py
#***程序功能：变量的作用域
#	示范了如何使用locals()、globals()函数
#	访问局部范围和全局范围内的“变量字典”。
#***编写日期：2019-5-18		
#*****************************
def test():
	age = 20
	#直接访问age局部变量
	print(age)		#输出20
	#访问函数局部范围内的“变量数组”
	print(locals())			#{'age':20}
	#通过函数局部范围内的“变量数组”访问age变量
	print(locals()['age'])
	#通过locals()函数局部范围内的“变量数组”改变age变量的值
	locals()['age'] = 12
	#再次访问age变量的值
	print('xxx',age)		#依然输出20
	#通过globals()函数修改x全局变量
	globals()['x'] = 19
x = 5
y = 20
print(globals())
#在全局范围内使用locals函数，访问的是全局变量的“变量数组”
print(locals())
#直接访问x全局变量
print(x)
#通过全局变量的“变量数组”访问x全局变量
print(globals()['x'])
#通过全局变量的“变量数组”对x全局变量赋值
globals()['x'] = 39
print(x)
#在全局范围内使用locals函数对x全局变量赋值
locals()['x'] = 99
print(x)

Python语法规定：在函数内部对不存在的变量赋值时，默认就是重新定义新的局部变量。就会发生局部变量遮蔽全局变量的情形。

例如：

#*****************************
#***程序名称：globals_test.py
#***程序功能：变量的作用域
#	局部变量遮蔽全局变量
#***编写日期：2019-5-18		
#*****************************
name = 'Charlie'
def test():
	#直接访问name全局变量
	#name = '孙悟空'		#会报错
	print(name)			#输出Charlie
test()
print(name)			#输出Charlie

解决这问题有两种方式：

（1）访问被遮蔽的全局变量（通过globals()函数）

例如：

#*****************************
#***程序名称：globals_right1.py
#***程序功能：变量的作用域
#	访问被遮蔽全局变量
#***编写日期：2019-5-18		
#*****************************
name = 'Charlie'
def test():
	#通过globals函数访问name全局变量
	print(globals()['name'])			#输出Charlie
	name = '孙悟空'
test()
print(name)			#输出Charlie

（2）在函数中声明全局变量

例如：

#*****************************
#***程序名称：globals_right2.py
#***程序功能：变量的作用域
#	在函数中声明全局变量
#***编写日期：2019-5-18		
#*****************************
name = 'Charlie'
def test():
	#声明name是全局变量，后面的赋值语句不会重新定义局部变量
	global  name
	#直接访问name全局变量
	print(name)		#输出Charlie
	name = '孙悟空'
test()
print(name)			#输出孙悟空

5.3 局部函数

定义：被放在函数体内定义的函数，被称为局部函数。

（1）在默认情况下，局部函数对外部是隐藏的，只能在其封闭函数内有效，其封闭函数也可以返回局部函数，以便程序在其他作用域中使用局部函数。

例如：

#*****************************
#***程序名称：local_function.py
#***程序功能：局部函数——被放在函数体内的函数
#只能在其封闭的函数内有效，其封闭函数也可以返回局部函数，以便
#在其他的作用域中使用局部函数。
#***编写日期：2019-5-18		
#*****************************
#定义函数，该函数会包含局部函数
def get_math_func(type , nn):
	#定义一个计算平方的局部函数
	def square(n):
		return n * n
	#定义一个计算立方的局部函数
	def cube(n):
		return n * n * n
	#定义一个计算阶乘的局部函数
	def factorial(n):
		result = 1
		for index in range(2 , n + 1):
			result *= index
		return result
	#调用局部函数
	if type == "square" :
		return square(nn)
	elif type == "cube" : 
		return cube(nn)
	else:
		return factorial(nn)
print(get_math_func("square" , 3))		#输出9
print(get_math_func("cube" , 3))		#输出27
print(get_math_func("" , 3))			#输出6

（2）局部函数内的变量遮蔽它所在函数内的局部变量。可以通过nonlocal语句声明访问赋值语句。

例如：

#*****************************
#***程序名称：nonlocal_test.py
#***程序功能：局部函数——通过nonlocal语句即可声明
#访问赋值语句只是访问该函数所在函数内的局部变量
#***编写日期：2019-5-18		
#*****************************
def foo():
	#局部变量name
	name = 'Charlie'
	def bar():
		nonlocal name
		#访问bar()函数所在foo()函数内的name局部变量
		#赋值前name的值
		print(name)		#Charlie
		name = '孙悟空'
		#赋值后name的值
		print(name)
	bar()
foo()

5.4 函数的高级内容

函数本身也是一个对象，既可以赋值，也可作为其他函数的参数，还可以作为其他函数的返回值。

5.4.1 使用函数作为变量

例如：

#*****************************
#***程序名称：function_var_test.py
#***程序功能：函数的高级用法
#***（1）把函数作为变量使用
#***编写日期：2019-5-18		
#*****************************
#定义一个计算乘方的函数
def pow(base , exponent):
	result = 1
	for i in range(1,exponent + 1):
		result *= base
	return result
#将pow函数赋值给my_fun，则my_fun可被当成pow使用
my_fun = pow
print(my_fun(3,4))		#输出81
#定义一个计算面积的函数
def area(width , height):
	return width * height
#将area函数赋值给my_fun，则my_fun可被当成area使用
my_fun = area
print(my_fun(3,4))		#输出12

5.4.2 使用函数作为函数形参

例如：

#*****************************
#***程序名称：function_param_test.py
#***程序功能：函数的高级用法
#***（2）把函数作为函数参数使用
#***编写日期：2019-5-18		
#*****************************
#定义函数类型的形参，其中fn是一个函数
def map(data , fn):
	result = []
	#遍历data列表中的每个元素，并用fn函数对每个元素进行计算
	#然后将计算结果作为新数组的元素
	for e in data :
		result.append(fn(e))
	return result
#定义一个计算平方的函数
def square(n):
	return n * n
#定义一个计算立方的函数
def cube(n):
	return n * n * n
#定义一个计算阶乘的函数
def factorial(n):
	result = 1
	for index in range(2 , n + 1):
		result *= index
	return result
data = [3,4,9,5,8]
print("原数据：" , data)
#下面程序代码调用map()函数三次，每次调用时传入不同的函数
print("计算数组元素的平方")
print(map(data,square))
print("计算数组元素的立方")
print(map(data,cube))
print("计算数组元素的阶乘")
print(map(data,factorial))

5.4.3 使用函数作为返回值

例如：

#*****************************
#***程序名称：function_return_test.py
#***程序功能：函数的高级用法
#***（3）把函数作为返回值
#***编写日期：2019-5-18		
#*****************************
def get_math_func(type):
	#定义一个计算平方的局部函数
	def square(n):
		return n * n
	#定义一个计算立方的局部函数
	def cube(n):
		return n * n * n
	#定义一个计算阶乘的局部函数
	def factorial(n):
		result = 1
		for index in range(2 , n + 1):
			result *= index
		return result
	#返回局部函数
	if type == "square" :
		return square
	if type == "cube" : 
		return cube
	else:
		return factorial
#调用get_math_func()，程序返回一个嵌套函数
math_func = get_math_func("cube")
print(math_func(5))
math_func = get_math_func("square")
print(math_func(5))
math_func = get_math_func("other")
print(math_func(5))

5.5 局部函数与lambda表达式

5.5.1 回顾局部函数

5.5.2 使用lambda表达式替代局部函数

利用lambda表达式简化function_return_test.py。

代码如下：

#*****************************
#***程序名称：lambda_test.py
#***程序功能：使用lambda表达式代替局部函数
#***编写日期：2019-5-18		
#*****************************
def get_math_func(type):
	result = 1
	#该函数返回的是lambda表达式
	if type == 'square':
		return lambda n: n * n
	elif type == 'cube' :
		return lambda n: n * n * n
	else:
		return lambda n: (1+n) * n / 2

#调用get_math_func()，程序返回一个嵌套函数
math_func = get_math_func("cube")
print(math_func(5))
math_func = get_math_func("square")
print(math_func(5))
math_func = get_math_func("other")
print(math_func(5))

注意：lambda表达式只能是单行表达式，不允许使用更复杂的函数形式。其本质就是匿名的、单行函数体的函数。

lambda表达式的语法格式：

lambda   [参数列表] : 表达式

两个用途：

（1）对于单行函数，使用lambda表达式可以省略去定义函数的过程，让代码更加简洁。

（2）对于不需要多次复用的函数，使用lambda表达式可以在用完之后立即释放，提高了性能。

例如：

#*****************************
#***程序名称：lambda_map.py
#***程序功能：使用lambda表达式调用Python内置的map()函数
#***编写日期：2019-5-18		
#*****************************
#传入计算平方的lambda表达式作为参数
x = map(lambda x: x*x , range(8))
print([e for e in x])	#[0, 1, 4, 9, 16, 25, 36, 49]
#传入计算平方的lambda表达式作为参数
y = map(lambda x : x * x if x % 2 == 0 else 0 ,range(8))
print([e for e in y])		#[0, 0, 4, 0, 16, 0, 36, 0]

 

大圣何来
关注
专栏目录
疯狂python讲义 笔记 第二章
weixin_44383328的博客
09-06 420
2 变量和简单类型 Python 是一门弱类型语言，弱类型包含两方面的含义： 所有变量无需声明即可使用，或者对没有用过的变量赋值就是声明了该变量。 变量的数据类型可以随时改变，同一个变量可以一会儿是数值型，一会儿说字符型 2.1 注释 给人看 控制范围修bug 2.2 变量 print() 函数默认以空格隔开多个变量（空格是默认分隔符）， 想要改变默认分隔符，可通过sep参数进行设置 例如...
疯狂python讲义视频 百度云-疯狂Python讲义 PDF 含源码工具版
weixin_37988176的博客
11-01 1234
给大家带来的一篇关于Python编程相关的电子书资源，介绍了关于Python编程、Python语法方面的内容，本书是由电子工业出版社出版，格式为PDF，资源大小124.3 MB，李刚编写，目前豆瓣、亚马逊、当当、京东等电子书综合评分为：8.3。内容介绍疯狂Python讲义内容介绍本书全面而深入介绍了Python编程的相关内容，全书内容大致可分为四个部分，*部分系统讲解了Python的基本语法结构、...
疯狂Python讲义笔记.pdf
02-26
疯狂Python讲义笔记 学习 李刚大师 疯狂python讲义所做笔记。非常值得一看哦。
《疯狂Python讲义》读书笔记——第4章 流程控制
大圣何来的博客
05-04 535
目录 4.1 顺序结构 4.2 if分支结构 4.2.1 不要忘记缩进 4.2.2 不要随意缩进 4.2.3 不要遗忘冒号 4.2.4 if条件的类型 4.2.5 if分支的逻辑错误 4.2.6 if表达式 4.2.7 pass语句（就是空语句） 4.3 断言（assert） 4.4 循环结构 4.4.1 while循环 4.4.2 使用while循环遍历列表和元组...
疯狂python讲义-第五章的笔记：函数和lambda表达式
renxanshou的博客
07-17 171
定义函数 5.1.3为函数提供文档 5.1.4多个返回值 5.1.5递归函数 5.2函数的参数 5.2.1关键字参数；意义不大吧； 5.2.2参数默认值 5.2.3参数收集（个数可变的参数）【加一个*号】 说是这样说，但是并不太实用吧~ 5.2.4逆向参数收集 5.3局部函数 5.4.1使用函数变量 将函数赋值给变量，程序通过...
疯狂Python讲义学习笔记——第3章列表、元组和字典3.2列表和元组的通用用法
最新发布
u013092707的博客
04-16 775
列表和元组非常相似，它们都可以包含多个元素，多个元素也有各自的索引。程序可通过索引来操作这些元素，只要不涉及改变元素的操作，列表和元组是通用的。
疯狂Python讲义笔记 Python基础入门到进阶知识手册 对照原文的笔记 由浅入深 循序渐进的笔记 共197页.pdf
05-24
《疯狂Python讲义笔记》是一本详尽的Python学习指南，涵盖了从基础到进阶的知识点，适合初学者和有一定经验的开发者。笔记内容丰富，包括变量和简单类型、列表、元组和字典、函数和lambda表达式、类和对象、异常处理...
Python讲义笔记资源
06-08
第5章 函数和lambda表达式 第6章 类和对象 第7章 异常处理 第8章 Python类的特殊方法 第9章 模块和包 第10章 常见模块 第11章 图形界面编程 第12章 文件I/O 第13章 数据库编程 第14章 并发编程 第15章 网络编程 第...
《疯狂Python讲义笔记》：全面掌握Python编程技巧
第5章 函数和lambda表达式 本章介绍函数的定义、参数传递、作用域以及如何使用lambda表达式创建匿名函数。学习者将了解如何通过函数封装代码，提高代码的可重用性和可读性。 第6章 类和对象 本章深入讲解面向对象...
疯狂Python讲义之列表使用笔记7
Xanthium
07-05 561
目录 1. 列表创建 2. 增加列表元素 3. 删除列表元素 4. 修改列表元素 5. 列表的其他常用方法 列表与元组最大的区别在于：元组是不可改变的，列表是可改变的。元组支持的操作，列表基本上都支持；列表支持对元素的修改，而元主且则不支持。从这个角度来看，可以认为列表是增强版的元组。 1. 列表创建 除使用前面介绍的方括号语法创建列表之外， Python 还提供了一...
疯狂的python学习笔记
08-02
疯狂的python学习笔记，能够通过简单的笔记快速学习python语句
python讲义 程序设计思想与方法6～13章
11-08
该PPT主要讲述了python的用法，里面涵盖了ptthon语言的各个知识点，课程资源还包含一些实例，便于学员快速掌握。
网易云课堂-疯狂的Python课程笔记-英雄无敌程序
07-18
来自于网易云课堂-疯狂的Python：零基础入门课程学习笔记，英雄无敌程序源码
疯狂Python讲义（习题答案）.rar
06-02
疯狂Python讲义（习题答案）.rar
Python疯狂讲义（文件I/O）
石头缝里的小松鼠（AlySam）
09-08 400
十、文件I/O 1、使用pathlib模块操作目录 PurePath：代表并不访问实际文件系统的“纯路径”。PurePath只是负责对路径字符串执行操作，至于该字符串是否对应实际的路径，不关心。PurePath有两个子类：PurePosixPath和PureWindowsPath分别代表UNIX（Mac OS X）和Windows的风格。 UNIX风格的路径和WIndows风格的路径的主要区别在于根路径和路径的分隔符：UNIX风格根路径是斜杠（/），Windows风格的根路径是盘符（c:）；UNIX风格
疯狂Python讲义笔记（2）
baidu_35525949的博客
08-31 146
第2章 变量和简单类型 2.1 单行注释和多行注释 Python源代码的注释有两种形式： 单行注释 多行注释 Python使用井号表示单行注释的开始，跟在“#”后面直到这行结束为止的代码都将被解释器忽略。单行注释就是在程序中注释一行代码，在Python程序中将井号放在需要注释的内容之前就可以了。 多行注释是指一次性将程序中的多行代码注释掉，在Python程序中使用三个单引号或三个双引号将注释的内容括起来。 # 这是一行简单的注释 print("Hello World!") ''' 这里面的内容全
C++lambda表达式
baizi1456的专栏
08-23 230
lambda表达式 C++ 语言中的lambda表达式在很多情况下提供了函数对象的另一种实现机制。Lambda表达式并不是STL所特有的，但它广泛应用于这一环境中。Lambda是表达式是定义一个没有名称、也不需要显示类定义的函数对象。Lambda表达式一般作为一种手段，用来将函数作为实参传递到另一个函数。相比于定义和创建一个常规的函数对象而言，lambda表达式非常容易使用和理解，而且...
Lambda表达式的五个练习
weixin_30821731的博客
06-06 598
Lambda表达式的五练习 语法： Lambda函数，是一个匿名函数，创建语法： lambda parameters:express parameters：可选，如果提供，通常是逗号分隔的变量表达式形式，即位置参数。 expression：不能包含分支或循环（但允许条件表达式），也不能包含return（或yield）函数。如果为元组，则应用圆括号将其包含起来。 调用lambda...
Python中匿名函数与lambda表达式实战应用
本资源主要介绍Python中的匿名或内联函数——lambda表达式。Lambda表达式是一种简洁的语法，用于定义简单的、单行的、只包含一个表达式的函数，常用于那些无需完整函数定义即可完成特定任务的情况，如排序操作（如`...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值