python3周末班2期第3天

今日课程大纲： 01 上周内容回顾 02 赋值运算与深浅拷贝 03 文件操作 简介 04 文件操作 读模式 05 文件操作 写模式 06 文件操作 追加模式 07 文件操作 修改 08 文件操作 其他方法 09 函数的初识 结构 作用 返回值 10 函数的参数 11 函数的命名空间和顺序 12 函数的嵌套 13 内置函数 globals()  locals() 14 函数的名称应用 15 关键字 global nonlocal

 

01 上周内容回顾

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 """
 4 格式化输出：
 5     % s d i f r
 6     format
 7         '{}{}{}'.format('alex',46,'women')
 8         '{0}{1}{2}{0}{0}'.format('alex',46,'women')
 9         '{name}{age}{hobby}'.format(age=46,name='alex',hobby='women')
10 
11 str:
12     s1 = 'alex'
13     print(s1[0])
14     print(s1[:2])
15     print(s1[::2])
16     upper() lower()
17     replace
18     calptlize()
19     strip()
20     split() 分割，str----> list
21     默认按照空格分割。指定分割符，指定分割次数。
22     find index:通过元素查找索引值。
23     join：将list ---> str 功能之一
24      '|'.join(iterable)
25      starstwith endswith
26      isdigit()
27      isalpha()
28      isalnum()
29     count()
30     内置函数：len() 取总长度
31 
32 list: 容器型数据类型，按照顺序存值。
33     索引切片（步长）
34     增： append() insert() extend()
35     删:  pop()  remove() clear()
36          del 索引切片（步长） del l1[1]
37     改
38         l1[0] = 'barry'
39         l1[:3] = 'barry'
40     查：
41         索引切片（步长）
42         for 循环
43     其他操作方法：
44         count index sort(reverse=True) 排序 reverse()
45         len()
46     range(10)
47     range(1,12,2)
48     for i in range(10,0,-1):
49         print(i)
50     l1 = [1,2,3,4,5]
51     for i in range(len(l1)):
52         print(i)
53 
54 tuple (1,2,3,4,[22]) 只读列表
55 
56 dict: key:value 大量关系型数据
57     查询速度快，数据之间的关系性强。
58     key: 不可变的数据类型。
59     values: 任意数据类型 对象。
60 
61     增：dic['name'] = 'Alex' setdefault
62     删：pop 按照key删除 del clear popitem(随机删除，但是3.6以后字典有序了)
63     改：dic[key] = 'value' update
64     查：
65         dic['key'] 如果没有此key
66         dic.get('key'，'设置返回值') 没有此键不报错,返回None,或者自己设定的值
67         dic.keys() dic.values() dic.items()
68         a,b = 1,2       分别赋值 a = 1  b = 2
69         a,b = (2,3)     a = 2  b = 3
70         for k,v in dic.items():
71             pass
72 
73 数据类型的补充：
74     数据类型的转换
75 编码：
76     str:python3x 编码是unicode
77     str ---> bytes
78     unicode ---> 非Unicode
79     s1 = 'alex'
80     b1 = s1.encode('utf-8') 编码
81     b1.decode('utf-8') 解码
82 
83     b1 gbk----->  b2  utf-8
84     b1.decode('gbk').encode('utf-8')
85 """

 

02 赋值运算与深浅拷贝

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 # 赋值运算
 4 # 可变的数据类型:由于数据类型可变，修改数据会在原来的数据的基础上进行修改，
 5 # 可变的数据类型有：列表，字典
 6 # l1 = [1,2,3]
 7 # l2 = l1
 8 # l3 = l2
 9 # # l1 = [1,2,3,4]     #注意这不是修改数据，而是在内存中重新创建了一份数据，然后L1 指向了这份新数据
10 # l1.append(666)       #在原来的数据上修改
11 # print(l1,l2,l3)
12 # print(id(l1),id(l2),id(l3))
13 # 不可变的数据类型:由于数据类型是不可变的，不可修改，会在内存中在重新创建一份新的数据
14 # 不可变的数据类型有：字符串，数字，bool值，元组等
15 # l4 = 'abcd'
16 # l5 = l4
17 # l4 = [1,2,3,]
18 # print(l4,l5)
19 # print(id(l4),id(l5))
20 
21 
22 # 浅copy
23 # copy一个新列表(dict)，列表在内存中是新的，但是列表里面的元素，完全沿用之前的元素。
24 # l1 = [1, 2, 3,[22,33]]
25 # l2 = l1.copy()
26 # print(id(l1),id(l2))
27 # l1.append(666)
28 # l1.remove(1)
29 # print(l1,l2)
30 # 列表在内存中是新的，但是列表里面的元素，完全沿用之前的元素
31 # print(id(l1[0]))
32 # print(id(l2[0]))
33 # l1[-1].append(666)
34 # print(l1,l2)
35 
36 
37 # 深copy
38 import copy
39 # 总结：深copy则会在内存中开辟新空间，将原列表以及列表里面的可变的数据类型重新创建一份，
40 # 不可变的数据类型则沿用之前的，指向之前的数据
41 # l1 = [1, 2, 3, [22, 33]]
42 # l2 = copy.deepcopy(l1)
43 # print(id(l1), id(l2))       #id 不一样，是两份数据
44 # l1[-1].append(666)
45 # l1.remove(1)                #只是删除了l1列表中和内存中的数据1的指向关系，并不是在内存中删除了数据1
46 # print(l1,l2)
47 
48 
49 # id 测试对象的内存地址
50 # == 比较 比较两边的数值是否相等
51 # print(2 == 2)
52 # is 判断 判断的两边对象的内存地址是否是同一个。
53 
54 
55 # ****** 切片是浅copy
56 # l1 = [1, 2, 3, [22, 33]]
57 # l2 = l1[:]  # 切片是浅copy
58 # l1[-1].append(666)
59 # # print(id(l1),id(l2)) 不是赋值关系
60 # print(l1,l2)

 

 

03 文件操作 简介

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 """
 4 文件三参数
 5     path：文件的路径
 6     encoding:文件以什么编码方式存储，就以什么编码方式读取
 7     mode:读，写，，读写，写读，追加，改等等
 8 
 9     三个大方向：
10         带b的模式操作对象都是非文字类的文件：视频，音频，图片。
11 
12         读（r rb r+ rb+）
13             r   读模式
14             rb
15             r+  读写模式
16             rb+
17 
18         写 w wb w+ w+b ：如果原文件存在，则清空原文件，在写入。这个慎用
19             w   写模式
20             wb
21             w+  写读模式
22             wb+
23 
24         追加(a ab a+ a+b)
25             a   追加
26             ab
27             a+
28             ab+
29 
30     文件操作的其他方法：
31         f.read()
32         f.write()
33         f.readline()
34         f.readlines()
35         f.close()
36         f.seek()
37         f.tell()
38 """
39 
40 
41 # f1 = open("文件读写test.txt",encoding='utf-8',mode='r')
42 # content = f1.read()
43 # print(content)
44 # f1.close()
45 """
46 f1变量,文件句柄。
47 open 内置函数,底层调用的操作系统的操作文件功能的接口。
48 windows: gbk，linux：utf-8  ios: utf-8
49 操作文件总共3步；
50     1，打开文件，产生文件句柄。
51     2，对文件句柄进行操作。
52     3，关闭文件句柄。
53 """
54 
55 
56 """
57 # 错误示范：
58 # 1，UnicodeDecodeError: 'gbk' codec can't decode...   编解码错误。
59 # 2,路径错误。路径分隔符 与后面的字符产生特殊的意义。 解决方式 r 或者 \
60     #f1 = open(r"d:\test\r文件读写test.txt",encoding='utf-8',mode='r')
61 """

 

04 文件操作 读模式

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 
 4 # 读模式（r rb r+ rb+）
 5 
 6 # r模式
 7 # 默认就是r模式
 8 # 1.1 read()    #全部读取文件内容，如果文件过大，可能会导致内存不足
 9 # f1 = open('文件读写test.txt', encoding='utf-8',mode='r')
10 # content = f1.read()
11 # print(content,type(content))  #对文件进行读取出来的都是字符串类型
12 
13 # 1.2 read(n)
14 # r模式下,  n代表字符。
15 # f1 = open('文件读写test.txt', encoding='utf-8',mode='r')
16 # content = f1.read(3)
17 # print(content)
18 
19 # 1.3 readline() 按行读取
20 # f1 = open('文件读写test.txt', encoding='utf-8',mode='r')
21 # print(f1.readline().strip())
22 # print(f1.readline().strip())
23 # f1.close()
24 
25 # 1.4 readlines()  返回一个列表,列表里面的元素是原文件每一行
26 # f1 = open('文件读写test.txt', encoding='utf-8',mode='r')
27 # content = f1.readlines()
28 # print(content)
29 # f1.close()
30 
31 
32 # 1.5 for循环  **注意平常读取大文件就需要用这种方法
33 # f1 = open('文件读写test.txt', encoding='utf-8',mode='r')
34 # for line in f1:
35 #     print(line.strip())
36 # f1.close()
37 
38 
39 # rb模式  ---读取一些非文字类的文件，如图片，视频等
40 # 也有上面说的那5中读的模式， read()  read(n)  readline()  readlines()  for循环读取
41 #如果是 rb 模式，就不需要规定编码了 encoding不是编码或解码，它是规定你这个文件到底采用哪种编码模式而已
42 ## f1 = open('文件读写test.txt', encoding='utf-8',mode='rb')
43 # f1 = open('文件读写test.txt',mode='rb')
44 # content = f1.read()
45 # print(content.decode('utf-8'))  #解码 utf-8 ---> unicode
46 # f1.close()
47 
48 # rb 模式读取图片
49 # f1 = open('time1.jpg', mode='rb')
50 # content = f1.read()
51 # print(content)
52 # f1.close()
53 
54 # r+ 读写模式
55 # f = open('log1',encoding='utf-8',mode='r+')
56 # print(f.read())
57 # f.write('666')
58 # f.close()
59 
60 # 先写后读会出问题
61 # f = open('log1',encoding='utf-8',mode='r+')
62 # f.write('松岛岛')
63 # print(f.read())
64 # f.close()
65 
66 #rb+ 模式

 

05 文件操作 写模式

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 # 第二写模式
 4 # w 写模式
 5 # 没有文件，创建文件写入内容
 6 # 有文件，先清空内容后写入
 7 # f = open('log1',encoding='utf-8',mode='w')
 8 # # f.write('林志玲 fjdsklafjsd;flj太白金星')
 9 # f.write('深圳校区 ~~~')
10 # f.write('深圳校区 ~~~')
11 # f.write('深圳校区 ~~~')
12 # f.write('深圳校区 ~~~')
13 # f.write('深圳校区 ~~~')
14 # f.close()
15 
16 # wb 写模式(以bytes类型写入到文件)
17 #rb
18 # f1 = open('time1.jpg', mode='rb')
19 # content = f1.read()
20 # print(content)
21 # f1.close()
22 # #wb 写入到文件
23 # #把bytes类型写入到文件 --图片
24 # f2 = open('time2.jpg',mode='wb')
25 # f2.write(content)
26 # f2.close()
27 
28 # w+ 写读模式
29 # f = open('log1',encoding='utf-8',mode='w+')
30 # f.write('老男孩教育...')
31 # f.seek(0)   #调整光标（指针）到最开始
32 # print(f.read())
33 # f.close()
34 
35 #wb+ 写读模式(bytes)

 

06 文件操作 追加模式

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 # a 追加
 4 # 没有文件创建文件追加内容，有文件，在文件最后追加内容。
 5 # f = open('log3',encoding='utf-8',mode='a')
 6 # f.write('老男孩')
 7 # f.close()
 8 #有文件，在文件最后追加内容。
 9 # f = open('log3',encoding='utf-8',mode='a')
10 # f.write('666')
11 # f.close()

 

07 文件操作 修改 

#!/usr/bin/env python3
#author:Alnk(李成果)
'''
文件的修改：所有的文件编辑器都要经过下面这5步才能对文件进行修改
    1,以读的模式打开原文件
    2，以写的模式打开新文件
    3，读取原文件对源文件内容进行修改形成新内容写入新文件
    4，将原文件删除
    5，将新文件重命名成原文件
'''
# 方法一 小文件可以。
# import os
#
# # 1,以读的模式打开原文件。
# # 2，以写的模式打开新文件。
# with open('alex个人简历',encoding='utf-8') as f1,\
#         open('alex个人简历.bak',encoding='utf-8',mode='w') as f2:
#     # 3，读取原文件对源文件内容进行修改形成新内容写入新文件。
#     old_content = f1.read()
#     new_content = old_content.replace('alex','SB')
#     f2.write(new_content)
#
# # 4，将原文件删除。
# os.remove('alex个人简历')
# # 5，将新文件重命名成原文件。
# os.rename('alex个人简历.bak','alex个人简历')


# 方法二： 推荐使用这种方法
import os
#
# 1,以读的模式打开原文件。
# 2，以写的模式打开新文件。
# with open('alex个人简历',encoding='utf-8') as f1,\
#         open('alex个人简历.bak',encoding='utf-8',mode='w') as f2:
#     # 3，读取原文件对源文件内容进行修改形成新内容写入新文件。
#     for old_line in f1:
#         new_line = old_line.replace('SB','alex')
#         f2.write(new_line)
#
# # 4，将原文件删除。
# os.remove('alex个人简历')
# # 5，将新文件重命名成原文件。
# os.rename('alex个人简历.bak','alex个人简历')

 

08 文件操作 其他方法

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 # 其他操作方法：
 4 # readable() writable()  ***      文件句柄是否可读，可写
 5 # seek 调整光标位置 按照字节   ***
 6 # seek(0)  将光标移动到开始
 7 # seek(0，2)  将光标移动到最后。
 8 # tell 获取光标位置 按照字节。  ***
 9 # flush 刷新 保存  ***
10 # truncate 截取原文件，从头开始截，
11 #
12 # f = open('log3',encoding='utf-8')
13 # f.seek(1)
14 # print(f.read())
15 # print(f.tell())
16 # f.seek(0) # 将光标移动到开始
17 # f.seek(0,2)  # 将光标移动到最后。
18 
19 # print(f.read())
20 # print(f.writable())
21 # if f.writable():
22 #     f.write('111')
23 # f.close()
24 
25 # f = open('log3',encoding='utf-8',mode='w')
26 # f.write('fjdsklafjdfjksa')
27 # f.flush()
28 # f.close()
29 
30 #截取原文件，从头开始截，需要在可写的模式下，并且不清空原文件
31 # f = open('log3',encoding='utf-8',mode='r+')
32 # f.truncate(3)
33 # f.close()

 

09 函数的初识 结构 作用 返回值

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 # 面向过程编程
 4 # s1 = 'fjksdfjsdklf'
 5 # count = 0
 6 # for i in s1:
 7 #     count += 1
 8 # print(count)
 9 #
10 # l1 = [1, 2, 3, 4, 5]
11 # count = 0
12 # for i in l1:
13 #     count += 1
14 # print(count)
15 #
16 # 缺点：
17 # 1，代码重复太多。
18 # 2，代码的可读性差。
19 
20 
21 #函数的初识
22 # def my_lf_len(s):
23 #     count = 0
24 #     for i in s:
25 #         count += 1
26 #     print(count)
27 #
28 # s1 = 'fjdsklafsdkalfjsda'
29 # my_lf_len(s1)
30 # l1 = [1,2,3,3,5,56,6,6]
31 # my_lf_len(l1)
32 #
33 # 函数是什么？
34 # 功能体，一个函数封装的一个功能
35 
36 
37 # 结构：
38 '''
39 def 函数名():
40     函数体
41 '''
42 
43 
44 # 函数什么时候执行？
45 # 被调用的时候执行。函数名+（）
46 # def my_lf_len(s):
47 #     count = 0
48 #     for i in s:
49 #         count += 1
50 #     print(count)
51 #
52 # my_lf_len('fdskfjskdlf')
53 
54 
55 # 函数的返回值 return
56 # def Tantan():
57 #     print('搜索')
58 #     print('左滑动一下')
59 #     print('右滑动一下')
60 #     # return
61 #     print('发现美女，打招呼')
62 #     # return '美女一枚'
63 #     # return ['恐龙一堆']
64 #     # return '小萝莉', '肯德基', '御姐'
65 #     return {'name':'alnk','age':18},[1,2,3,4,5,]    #这算多个值
66 # ret = Tantan()
67 # print(ret,type(ret))
68 #
69 # 调用一次执行一次
70 # Tantan()
71 # Tantan()
72 # Tantan()
73 #
74 # 返回值
75 '''
76 return: 
77     1,终止函数。
78     2，给函数的调用者（执行者）返回值。
79         return             --->  None 
80         return   单个值    --->  单个值   --被返回的数据是什么数据类型就是什么类型
81         return   多个值    ---> (多个值,) --元组
82 '''

 

10 函数的参数 

  1 #!/usr/bin/env python3
  2 #author:Alnk(李成果)
  3 # def Tantan(sex):  #函数的定义:sex形式参数，形参
  4 #     print('搜索')
  5 #     print('左滑动一下')
  6 #     print('右滑动一下')
  7 #     print('发现美女，打招呼')
  8 #     return '小萝莉', '肯德基', '御姐'
  9 #
 10 # # 函数的参数
 11 # Tantan('女') # 函数的执行：'女' 实际的数据， 实参。
 12 
 13 
 14 #从两方面将函数的参数：实参 和 形参
 15 # 实参角度
 16 # 1.位置参数。  从左至右，一一对应
 17 # def Tantan(sex,age):
 18 #     print('筛选性别%s,年龄%s左右' %(sex,age))
 19 #     print('搜索')
 20 #     print('左滑动一下')
 21 #     print('右滑动一下')
 22 #     print('发现美女，打招呼')
 23 #
 24 # Tantan('女',28,)
 25 #
 26 # 练习：比大小，返回大的数字
 27 # def max_(a,b): return a if a > b else b
 28 #     # if a > b:
 29 #     #     return a
 30 #     # else:
 31 #     #     return b
 32 #     # return a if a > b else b
 33 # print(max_(100,200))
 34 #
 35 # 扩展：
 36 # 三元运算符
 37 # a = '饼'
 38 # b = '西瓜'
 39 # ret = a if 3 > 2 else b
 40 # print(ret)
 41 
 42 # 2.关键字参数。 一一对应。
 43 # 函数参数较多 记形参顺序较麻烦时，需要关键字参数。
 44 # def Tantan(sex,age,area):
 45 #     print('筛选性别%s, %s附近，年龄%s左右的美女' %(sex,area,age))
 46 #     print('搜索')
 47 #     print('左滑动一下')
 48 #     print('右滑动一下')
 49 #     print('发现美女，打招呼')
 50 # Tantan(sex='女',area='南山区',age='28')
 51 
 52 # 3.混合参数 : 一一对应,关键字参数必须要在位置参数后面。
 53 # def Tantan(sex,age,area):
 54 #     print('筛选性别%s,%s 附近，年龄%s左右的美女' %(sex,area,age))
 55 #     print('搜索')
 56 #     print('左滑动一下')
 57 #     print('右滑动一下')
 58 #     print('发现美女，打招呼')
 59 # Tantan('女',28,area='南山区')
 60 
 61 
 62 # 形参角度
 63 # 1.位置参数。 从左至右，一一对应。
 64 # def Tantan(sex,age):
 65 #     print('筛选性别%s,年龄%s左右' %(sex,age))
 66 #     print('搜索')
 67 #     print('左滑动一下')
 68 #     print('右滑动一下')
 69 #     print('发现美女，打招呼')
 70 # Tantan('女',28,)
 71 
 72 # 2.默认参数  : 使用最多的一般不更改的参数，默认参数一定放在位置参数后面
 73 # def Tantan(area,age,sex='girl'):
 74 #     print('筛选性别%s, %s 附近，年龄%s左右的美女' %(sex,area,age))
 75 #     print('搜索')
 76 #     print('左滑动一下')
 77 #     print('右滑动一下')
 78 #     print('发现美女，打招呼')
 79 # Tantan('南山区',28,'laddboy')
 80 
 81 # 3.万能参数（动态参数） *args, **kwargs
 82 # def Tantan(*args,**kwargs):
 83 #     # 函数的定义： * 代表聚合。
 84 #     # * 将实参角度所有的位置参数放到一个元祖中，并将元组给了args
 85 #     # ** 将实参角度所有的关键字参数放到一个字典中，并将字典给了kwargs
 86 #     # print('筛选性别%s, %s 附近，年龄%s左右的美女' %(sex,area,age))
 87 #     # print(args)
 88 #     # print(kwargs)
 89 #     print('筛选地域：%s,年龄%s' % args)
 90 #     print('搜索')
 91 #     print('左滑动一下')
 92 #     print('右滑动一下')
 93 #     print('发现美女，打招呼')
 94 #
 95 # # Tantan('南山区','28', '性格好','身材好', '家境好')
 96 # Tantan('南山区','28',body='身材好',voice='萝莉音',money='白富美')
 97 #
 98 # def Tantan(*args,**kwargs):
 99 #     # 函数的定义： * 代表聚合。
100 #     # * 将实参角度所有的位置参数放到一个元祖中，并将元组给了args
101 #     # ** 将实参角度所有的关键字参数放到一个字典中中，并将字典给了kwargs
102 #     print(args)
103 #     print(kwargs)
104 #
105 # Tantan('南山区','28',body='身材好',voice='萝莉音',money='白富美')
106 # l1 = [1,2,3]
107 # l2 = (4,5,6)
108 # Tantan(*l1,*l2)  # 函数的执行：*iterable 将l1打散，添加到args
109 # Tantan(1, 2, 3, 4, 5, 6)
110 # dic1 = {'name':"alex"}
111 # dic2 = {'age':46}
112 # Tantan(**dic1,**dic2)     #**dic1 将dic1打散，将所有的键值对添加到kwargs
113 
114 
115 # 形参的最终顺序
116 # 位置参数  *args  默认参数 **kwargs
117 # def func(a,b,*args,sex='女',**kwargs):
118 #     print(a,b,sex,args,kwargs)
119 # func(1,2,4,5,6,name='alex',age=73) 

 

11 函数的命名空间和顺序

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 """
 4 函数里面的变量，在函数外面能直接引用么？
 5 def func1():
 6     m = 1
 7     print(m)
 8 print(m)  #这行报的错
 9 
10 报错了：
11 NameError: name 'm' is not defined
12 
13 我们首先回忆一下Python代码运行的时候遇到函数是怎么做的，从Python解释器开始执行之后，就在内存中开辟里一个空间。
14 每当遇到一个变量的时候，就把变量名和值之间对应的关系记录下来，但是当遇到函数定义的时候，解释器只是象征性的将函数名读入内存，
15 表示知道这个函数存在了，至于函数内部的变量和逻辑，解释器根本不关心。等执行到函数调用的时候，
16 Python解释器会再开辟一块内存来储存这个函数里面的内容，这个时候，才关注函数里面有哪些变量，
17 而函数中的变量会储存在新开辟出来的内存中，函数中的变量只能在函数内部使用，并且会随着函数执行完毕，这块内存中的所有内容也会被清空。
18 
19 我们给这个‘存放名字与值的关系’的空间起了一个名字 --- 命名空间。
20 代码在运行伊始，创建存储“变量名与值的关系”的空间叫做全局命名空间；
21 在函数的运行中开辟的临时的空间叫做局部命名空间。
22 """
23 # python的空间分三种：
24 # 全局名称空间
25 # 局部名称空间
26 # 内置名称空间  print() len() 内置函数
27 #
28 # 举例
29 # def func():
30 #     name = 'alex'
31 # func()
32 # print(name)
33 # func()
34 # python中的作用域分两种：
35 # 全局作用域：内置名称空间 全局名称空间
36 # 局部作用域：局部名称空间
37 
38 
39 # 取值顺序: 就近原则
40 # 局部变量先到局部寻找，局部没找到才去全局找，全局没找到，去内置找，都没找到，就报错
41 # 全局变量直接在全局查找，全局没有就去内置空间查找，如果没有，就报错
42 # 局部名称空间 ———> 全局名称空间 ———> 内置名称空间    （这个顺序不可逆）
43 # input = 'barry'
44 # def func():
45 #     # input = 'alex'
46 #     print(input)
47 # func()
48 # print(input)
49 
50 
51 # 加载顺序
52 # 所有的东西要加载到内存才运行
53 # 内置名称空间  --->  全局名称空间 --->  局部名称空间

 

12 函数的嵌套

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 # 函数的嵌套
 4 # 举例1
 5 # def func():
 6 #     print(111)
 7 #
 8 # def func1():
 9 #     print(222)
10 #     func()
11 #
12 # def func3():
13 #     print(333)
14 #     func1()
15 #
16 # print(444)
17 # func()
18 # print(555)
19 # 444 111 555
20 #
21 #举例2
22 # def func():
23 #     print(111)
24 #
25 # def func1():
26 #     print(222)
27 #     func()
28 #
29 # def func3():
30 #     print(333)
31 #     func1()
32 #
33 # print(444)
34 # func3()
35 # print(555)
36 # 444 333 222 111 555
37 #
38 # def wrapper():
39 #     print(222)
40 #     def inner():
41 #         print(111)
42 #     print(444)
43 #     inner()
44 #     print(333)
45 #
46 # wrapper()
47 # 222 444 111 333

 

13 内置函数 globals()  locals()

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 """
 4 本文件主要讲述内置函数globals() locals()
 5 """
 6 # name = 'alex'
 7 # age = 46
 8 #
 9 # def func():
10 #     sex = '男'
11 #     hobby = '女'
12 #     print(globals())  # 返回一个字典：全局作用域的所有内容
13 #     print(locals())   # 返回一个字典：当前位置的内容
14 # func()
15 #
16 # print(globals())  # 返回一个字典：全局作用域的所有内容
17 # print(locals())   # 返回一个字典：当前位置的内容

 

14 函数的名称应用 

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 # 函数名的应用
 4 # 1,函数名是一个特殊的变量 函数名() 执行此函数
 5 # def func():
 6 #     print(666)
 7 # func()
 8 
 9 # 2,函数名可以当做变量进行赋值运算。
10 # def func():
11 #     print(666)
12 #
13 # f = func
14 # f()
15 
16 # 3，函数名可以作为容器型数据的元素 ***
17 # def func():
18 #     print(666)
19 #
20 # def func1():
21 #     print(777)
22 #
23 # def func2():
24 #     print(888)
25 #
26 # def func3():
27 #     print(999)
28 #
29 # l1 = [func, func1, func2, func3]
30 # for i in l1:
31 #     i()
32 #
33 # dic = {
34 #     1: func,
35 #     2: func1,
36 #     3: func2,
37 #     4: func3,
38 # }
39 #
40 # while 1:
41 #     num = input('请输入序号：').strip()
42 #     num = int(num)
43 #     dic[num]()
44 
45 # 4，函数名可以作为函数的参数。
46 # def func1():
47 #     print(111)
48 #
49 # def func2(x):
50 #     x()
51 #     print(222)
52 #
53 # func2(func1)
54 
55 # 5，函数名可以作为函数的返回值。
56 # def func1():
57 #     print(111)
58 #
59 # def func2(x):
60 #     print(222)
61 #     return x
62 #
63 # ret = func2(func1)
64 # ret()

 

15 关键字 global nonlocal

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 # global nonlocal
 4 #
 5 # global
 6 #1，声明一个全局变量。
 7 # def func():
 8 #     global name
 9 #     name = 'alex'
10 # func()
11 # print(name)
12 
13 # 2,修改一个全局变量。
14 # 原因：局部作用域只能引用全局变量而不能改变全局变量。如果改变则报错
15 # global 可以实现通过局部作用域而去改变全局变量
16 # count = 1
17 # def func1():
18 #     global count
19 #     count += 1
20 # print(count)
21 # func1()
22 # print(count)
23 
24 
25 # nonlocal： 子级函数可以通过nonlocal修改父级（更高级非全局变量）函数的变量。
26 # 现象：子级函数可以引用父级函数的变量但是不能修改。
27 def func():
28     count = 1
29     def func1():
30         def inner():
31             nonlocal count
32             count += 1
33             print(count)  # 2
34         print(count)      # 1
35         inner()
36         print(count)      # 2
37     func1()
38 func()
39 
40 # 这个不行，会报错
41 # count = 1
42 # def func1():
43 #     def inner():
44 #         nonlocal count
45 #         count += 1
46 #         print(count)
47 #     inner()
48 #
49 # func1()

 

转载于:https://www.cnblogs.com/lichengguo/p/10272736.html