python 3

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)