发表更新学习3 分钟读完 (大约523个字)

Py函数闭包

1. 定义

闭包是函数式编程的一个重要的语法结构，函数式编程是一种编程范式 (而面向过程编程和面向对象编程也都是编程范式)。

在面向过程编程中，我们见到过函数(function)；

在面向对象编程中，我们见过对象(object)；

函数和对象的根本目的是以某种逻辑方式组织代码，并提高代码的可重复使用性(reusability)；

阅读更多
发表更新学习1 分钟读完 (大约208个字)

python查漏补缺之基本的数据结构

列表

删除列表元素

1
del list[2]

Python列表脚本操作符

len([1,2,3])，结果为3

[1,2,3]+[4,5,6]，结果为[1,2,3,4,5,6]

['Hi']*4，结果为['Hi'.'Hi','Hi','Hi']

3 in [1,2,3]，结果为True

for x in [1,2,3]: print(x,end="")，结果为1 2 3

Py列表拼接

1
2
3
4
5
>>>squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>

元组

元祖的元素不可修改。

元组使用小括号，列表使用方括号。

修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下：

1
2
3
4
5
6
7
8
9
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2;
print (tup3)

结果为：

1
(12, 34.56, 'abc', 'xyz')

元组运算符

py表达式 结果 描述
len((1, 2, 3)) 3 计算元素个数
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 连接
('Hi!',) * 4 (‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’) 复制
3 in (1, 2, 3) True 元素是否存在
for x in (1, 2, 3): print (x,) 1 2 3 迭代
发表更新学习2 分钟读完 (大约313个字)

python查漏补缺之zip()

描述

zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
可以使用list()转换来输出列表。

若各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用*号操作符，可以将元祖解压为列表。

例1

1
2
3
4
5
6
7
a = [1,2,3]
c = [1,2,3,4]

zipped = zip(a,c)
l_zipped = list(zipped)
b = 3
print(type(zipped),type(l_zipped))

输出结果为：

1
2
<class 'zip'> <class 'list'>
[(1, 1), (2, 2), (3, 3)]

例2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
a = [
    [1,2],
    [3,4],
    [5,6]
]
c = [
    [5,6],
    [7,8],
    [9,10]
]
zipped = zip(a,c)
l_zipped = list(zipped)
b = 3
print(type(zipped),type(l_zipped))

print(l_zipped)

输出结果：

1
2
3
<class 'zip'> <class 'list'>
[([1, 2], [5, 6]), ([3, 4], [7, 8]), ([5, 6], [9, 10])]

例3

1
2
3
4
5
6
7
8
9
10
11
12
a = [1,2,3]
c = [1,2,3,4]

zipped = zip(a,c)
print(zipped,type(zipped))
accmulated = 1*[0]
accmulated = [x_c[0] + x_c[1] for x_c in zip(a,c)]
for i in zipped:
    print(i,type(i))
l_zipped = list(zipped)    # 转换为列表
#print(l_zipped)
print("accmulated:",accmulated)

输出结果：

1
2
3
4
5
<zip object at 0x7f3128d8d5c8> <class 'zip'>
(1, 1) <class 'tuple'>
(2, 2) <class 'tuple'>
(3, 3) <class 'tuple'>
accmulated: [2, 4, 6]

例4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
a = [
    [1,2],
    [3,4],
    [5,6]
]
c = [
    [5,6],
    [7,8],
    [9,10]
]
zipped = zip(a,c)
l_zipped = list(zipped)
accmulated = 1 *[0]
# 注：此处将zip(a,c)换为zipped则显示为空
for i in zip(a,c):
    print(i,type(i))
accmulated = [x_c[0] + x_c[1] for x_c in zip(a,c)]
print("accmulated:",accmulated)

输出结果：

1
2
3
4
5
([1, 2], [5, 6]) <class 'tuple'>
([3, 4], [7, 8]) <class 'tuple'>
([5, 6], [9, 10]) <class 'tuple'>
accmulated: [[1, 2, 5, 6], [3, 4, 7, 8], [5, 6, 9, 10]]

例5：矩阵的行列互换

1
2
3
a = [[1,2,3],[3,4,5]]
a1 = zip(*a)
print(list(a1))

输出结果：

1
[(1, 3), (2, 4), (3, 5)]
发表更新学习14 分钟读完 (大约2164个字)

python函数

可更改与不可更改对象

在python中，strings，tuples和numbers是不可更改的对象，而list，dict是可以修改的对象。

  • 不可变类型：变量a=5后再赋值a=10，这里实际是新生成一个int值对象10，再让a指向它，而5被丢弃，不是改变a的值，相当于新生成了a。
  • 可变类型：变量a=[1,2,3,4]后再赋值la[2]=5则是将list la的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python的参数传递：

  • 不可变类型：类似c++的值传递，如整数、字符串、元组。如fun(a)，传递的只是a的值，没有影响a对象本身。比如在fun(a)内部修改a的值，只是修改另一个复制的对象，不会影响a本身。
  • 可变类型：类似c++的引用传递，如列表，字典。如fun(la)，则是将la真正的传过去，修改后fun外部的la也会受影响。

python中一切都是对象，严格意义上不能说值传递还是引用传递，应该说传不可变对象和传可变对象。

python 传不可变对象实例

1
2
3
4
5
6
def ChangeInt(a):
    a = 10

b = 2
ChangInt(b)
print(b)

传可变对象实例
可变镀锡在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。

1
2
3
4
5
6
7
8
9
10
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)

参数

以下是调用函数时可使用的正式参数类型：

  • 必需参数
  • 关键字参数
  • 默认参数
  • 不定长参数

必需参数
必需参数须以正确的顺序传入函数，调用时的数量必须和声明时的一样。
调用printme()函数，你必须传入一个参数，不然会出现语法错误：

1
2
3
4
5
6
7
8
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
#调用printme函数
printme()

关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为Python解释器能够用参数名匹配参数值。
以下实例在函数printme()调用时使用参数名：

1
2
3
4
5
6
7
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
#调用printme函数
printme( str = "菜鸟教程")

以下实例演示了函数参数的使用不需要使用指定顺序：

1
2
3
4
5
6
7
8
9
#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )

默认参数
调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入age参数，则使用默认值：

1
2
3
4
5
6
7
8
9
10
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

不定长参数
Python中的函数可以处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：

1
2
3
4
def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

加上星号*的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

1
2
3
4
5
6
7
8
9
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

还有一种就是参数带两个星号**基本语法如下：

1
2
3
4
def functionname([formal_args,] **var_args_dict ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了两个星号**的参数会以字典的形式导入。

1
2
3
4
5
6
7
8
9
# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

声明函数时，参数中星号*可以单独出现，例如：

1
2
def f(a,b,*,c):
    return a+b+c

如果单独出现星号*后的参数必须用关键字传入。

匿名函数

python使用lambda来创建匿名函数。
所谓匿名，是指不再使用def语句这样的标准形式定义一个函数。

  • lambda只是一个表达式，函数体比def简单很多。
  • lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
  • lambda函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
  • 虽然lambda函数看起来只能写一行，却不等同于c或c++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法
lambda函数的语法只包含一个语句，如下：

1
lambda [arg1 [,arg2,.....argn]]:expression

如下实例：

1
2
3
4
5
6
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

变量作用域

Python中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量在哪里赋值的。
变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：

  • L(Local) 局部作用域
  • E(Enclosing) 闭包函数外的函数中
  • G(Global) 全局作用域
  • B(Built-in) 内置作用域（内置函数所在模块的范围）

以L -> E -> G -> B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找。

1
2
3
4
5
g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域

内置作用域是通过一共名为builtin的标准模块来实现的，但是这个变量名自身并没有放入内置作用域内，所以必须导入这个文件才能够使用它。在Python3.0中，可以使用以下的代码来查看到底预定义了哪些变量：

1
2
>>> import builtins
>>> dir(builtins)

Python中只有模块(module)，类(class)以及函数(def、lambda)才会引入新的作用域，其它的代码块（如if/elif/else、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问，如下代码：

1
2
3
4
5
>>> if True:
...  msg = 'I am from Runoob'
>>> msg
'I am from Runoob'
>>>

实例中msg变量定义在if语句块中，但外部还是可以访问的。
如果将msg定义在函数中，则它就是局部变量，外部不能访问。

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内部声明的变量名称都将被加入到作用域中。如下实例：

1
2
3
4
5
6
7
8
9
10
11
total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
    #返回2个参数的和."
    total = arg1 + arg2 # total在这里是局部变量.
    print ("函数内是局部变量 : ", total)
    return total
 
#调用sum函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total)

global和nonlocal关键字

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。
以下实例修改全局变量num:

1
2
3
4
5
6
7
8
9
#!/usr/bin/python3
num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()
print(num)

如果要修改嵌套作用域(enclosing作用域，外层非全局作用域)中的变量则需要nonlocal关键字，如下实例：

1
2
3
4
5
6
7
8
9
10
11
#!/usr/bin/python3
 
def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()
关注我

链接

分类

最新文章

标签

BFS3
DFS3
Java面经1
algorithm4
android1
bfs2
c++9
dfs7
dp1
dpLearning13
java1
jvm9
ordered-map1
python8
spring6
sql3
tools16
二分查找1
二叉树13
位运算10
傻屌题1
分治2
分治算法2
动态规划6
双指针7
哈希1
哈希表2
回溯5
堆2
堆排序1
多线程1
字符串5
总结1
找规律2
指针1
排序9
数字1
数据库1
数组9
最短路径1
查找2
栈9
树12
测试6
测试知识1
滑动窗口1
自动机1
计算机基础2
计算机网络1
计算机网络基础1
论文阅读10
设计1
贪心算法3
较难13
递归6
链表14
队列1
需要review8
面试记录1
×