A.函数:
一、 Python 中,根据实际参数的类型不同,函数参数的传递方式可分为 2 种,分别为值传递和引用(地址)传递:
1.值传递:适用于实参类型为不可变类型(字符串、数字、元组);
2.引用(地址)传递:适用于实参类型为可变类型(列表,字典);
二、可变参数 :形参前添加一个 ‘*’
三、可变参数:形参前添加两个’’
四、逆向参数收集
所谓逆向参数收集,指的是在程序己有列表、元组、字典等对象的前提下,把它们的元素“拆开”后传给函数的参数。逆向参数收集需要在传入的列表、元组参数之前添加一个星号,在字典参数之前添加两个星号。
def test(name, message):
print("用户是: ", name)
print("欢迎消息: ", message)
my_list = ['孙悟空', '欢迎来C语言中文网']
test(*my_list)
五.全局,局部变量
1.局部变量
局部变量是指在函数内部定义并使用的变量,它只在函数内部有效。
2.全局变量
定义全局变量的方式有以下 2 种:
1.在函数体外定义的变量,一定是全局变量,
2.在函数体内定义全局变量。即使用 global 关键字对变量进行修饰后,该变量就会变为全局变量。
3,获取指定作用域范围中的变量
globals():该函数返回全局范围内所有变量组成的“变量字典”。
locals():该函数返回当前局部范围内所有变量组成的“变量字典”。
vars(object):获取在指定对象范围内所有变量组成的“变量字典”。如果不传入object 参数,vars() 和 locals() 的作用完全相同。
4.遮蔽问题
Python 语法规定,在函数内部对不存在的变量赋值时,默认就是重新定义新的局部变量,这会使得函数内部遮蔽重名的 name 全局变量。由于局部变量 name 在 print(name) 后才初始化,所以程序会报错。
为了避免这个问题,可以通过以下两种方式来修改上面程序:
访问被遮蔽的全局变量。如果希望程序依然能访问 name 全局变量,且在函数中可重新定义 name 局部变量,也就是在函数中可以访问被遮蔽的全局变量,此时可通过 globals() 函数来实现,将上面程序改为如下形式即可:
纯文本复制
name = 'Charlie'
def test ():
# 直接访问name全局变量
print(globals()['name']) # Charlie
name = '孙悟空'
test()
print(name) # Charlie
在函数中声明全局变量。为了避免在函数中对全局变量赋值(不是重新定义局部变量),可使用 global 语句来声明全局变量。因此,可将程序改为如下形式:
name = 'Charlie'
def test ():
# 声明name是全局变量,后面的赋值语句不会重新定义局部变量
global name
# 直接访问name全局变量
print(name) # Charlie
name = '孙悟空'
test()
print(name) # 孙悟空
增加了“global name”声明之后,程序会把 name 变量当成全局变量,这意味着 test() 函数后面对 name 赋值的语句只是对全局变量赋值,而不是重新定义局部变量。
5.局部函数
为了声明 bar() 函数中的“name=‘孙悟空’”赋值语句不是定义新的局部变量。
只是访问它所在 foo() 函数内的 name 局部变量,Python 提供了 nonlocal 关键字,通过 nonlocal 语句即可声明访问赋值语句只是访问该函数所在函数内的局部变量。将上面程序改为如下形式:
def foo ():
# 局部变量name
name = 'Charlie'
def bar ():
nonlocal name
# 访问bar函数所在的foo函数的name局部变量
print(name) # Charlie
name = '孙悟空'
bar()
foo()
增加上面程序中第 5 行之后,接下来 bar() 函数中的“name=‘孙悟空’”就不再是定义新的局部变量,而是访问它所在函数(foo() 函数)内的 name 局部变量。
6.lambda 表达式
lambda 表达式的语法格式如下:
lambda [parameter_list] : 表达式
从上面的语法格式可以看出 lambda 表达式的几个要点:
lambda 表达式必须使用 lambda 关键字定义。
在 lambda 关键字之后、冒号左边的是参数列表,可以没有参数,也可以有多个参数。如果有多个参数,则需要用逗号隔开,冒号右边是该 lambda 表达式的返回值。
map() 会根据提供的函数对指定序列做映射。
# 传入计算平方的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]
7.列表推导式的语法------------快速生成一个满足指定需求的列表。
格式如下:
[表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] ]
8.元组推导式的语法格式如下:
(表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] )
9.字典推导式
{表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]}
===============================================
listdemo = ['C语言中文网','c.biancheng.net']
#将列表中各字符串值为键,各字符串的长度为值,组成键值对
newdict = {key:len(key) for key in listdemo}
print(newdict)
10.集合推导式
{ 表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] }
setnew = {i**2 for i in range(3)}
print(setnew)
运行结果为:
{0, 1, 4}
11.zip() 函数
zip() 函数可以把两个列表“压缩”成一个 zip 对象(可迭代对象),这样就可以使用一个循环并行遍历两个列表。
>>> a = ['a','b','c']
>>> b = [1, 2, 3]
>>> [x for x in zip(a,b)]
[('a', 1), ('b', 2), ('c', 3)]
如果 zip() 函数压缩的两个列表长度不相等,那么 zip() 函数将以长度更短的列表为准。
>>> c = [0.1 ,0.2]
>>> [x for x in zip(a,c)]
[('a', 0.1), ('b', 0.2)]
下面代码示范了使用 zip() 函数来实现并行遍历的效果:
books = ['疯狂Kotlin讲义', '疯狂Swift讲义', '疯狂Python讲义']
prices = [79, 69, 89]
# 使用zip()函数压缩两个列表,从而实现并行遍历
for book, price in zip(books, prices):
print("%s的价格是: %5.2f" % (book, price))
12.reversed()
>>> a = range(10)
>>> [x for x in reversed(a)]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
reversed() 当然也可以对列表、元组、数组,str进行反转。
>>> c = 'Hello,Charlie'
>>> [x for x in reversed(c)]
['e', 'i', 'l', 'r', 'a', 'h', 'C', ',', 'o', 'l', 'l', 'e', 'H']
13.sorted()
sorted(a, reverse = True)
13.1sorted方法和列表的sort方法使用详解
1.列表有自己的sort方法,其对列表进行原址排序,无返回值。
listname.sort()
sorted返回一个有序的副本,并且类型总是列表。
sorted(a)