python学习笔记全过程_Python学习过程笔记整理（四）

变量作用域

-分类

-全局(global):在函数外部定义：整个全局范围都有效

-局部(local):在函数内部定义：仅在局部范围有效

-提升局部变量为全局变量

-使用global

-globals,locals内建函数

1 a = 1

2 b = 2

3 deffun(a,b):4 c = 3

5 print("Locals = {0}".format(locals()))6 print("Globals = {0}".format(globals())) #打印的不仅是a，b，还有其他所有的全局变量，包括python自带的

7 fun(a,b)

-eval()、exec()函数

-把一个字符串当成一个表达式执行，eval()返回表达式执行后的结果，exec()返回None

-语法

eval(string_code, globals=None, locals=None)

exec(string_code, globals=None, locals=None)

1 x = 100

2 y = 200

3 z1 = eval("x+y")4 z2 = exec("x+y")5 print(z1) #300

6 print(z2) #None

7

8 #以下eval和exec结果相同

9 z1 = eval("print('x+y=:',x+y)") #x+y=: 300

10 z2 = exec("print('x+y=:',x+y)") #x+y=: 300

11 print(z1) #None

12 print(z2) #None

-递归函数

-函数直接或者间接调用自身

-python对递归深度有限制，超过限度报错

1 #斐波那契数列，只考虑正常输入的n

2 deffib(n):3 if n == 1 or n ==2:4 return 1

5 return fib(n-2) + fib(n-1)6

7 print(fib(5))

1 #汉诺塔程序，只考虑正常输入

2 defhano(n, a, b, c):3 """

4 汉诺塔的的递归实现5 :param n: 一共有n个盘子6 :param a: 起始塔7 :param b: 过渡塔8 :param c: 目标塔9 :return: None10 """

11 if n == 1:12 #print(a, b, c, n,"*" * 30) 理解程序的调试语句

13 print(a, "-->", c)14 returnNone15 if n == 2: #实际上该部分可以省略

16 #print(a, b, c, n,"*" * 20) 理解程序的调试语句

17 print(a, "-->", b)18 print(a, "-->", c)19 print(b, "-->", c)20 returnNone21 #当n>=3时，把n-1个盘子借助c，从a移动到b上

22 #print(a, b, c, n-1,"*" * 10) 理解程序的调试语句

23 hano(n-1, a, c, b)24 print(a, "-->", c)25 #而后把n-1个盘子，借助a，从b移动到c上

26 hano(n-1, b, a, c)27 returnNone28 a = "A"

29 b = "B"

30 c = "C"

31 n = 4

32 hano(n, a, b, c)

变量类型(内置数据结构)

-list(列表)

-使用下标访问，从0开始：print(l[2])

-分片操作：对列表进行任意一段的截取：print(l[1:3])

-包含左不包含右：只取l[1]和l[2]

-:左或者右不写，左边默认0，右边默认最后一个数据：print(l[:])

-有步长，默认为1：print(l[1:6:3])，最后一个是步长，修改为3

-下标可以超出范围，超出后不报错，不考虑多余的下标内容

-下标为负数：表示从右往左，最后一个下标为-1。注意：分片截取左边值比右边大时，步长注意需要使用负数

-一些常规操作

1 l = [0,1,2,3,4,5,6]2 print(l, "输出原始l")3 last_ele = l.pop() #取出最后一个元素

4 print(last_ele, "输出取出的最后一个元素的值")5 print(l, "输出被取出最后一个元素以后的l")6 del l[2] #删除制定index元素

7 l.remove(0) #删除指定的值

8 print(l, "输出删除index为2，以及元素值为0后的l")9 l.append(2) #追加元素

10 l.insert(3,"a") #插入元素，index前面

11 print(l, "输出追加元素值为2，以及在index=3前面插入a的l")12 a = [7,8,9]13 b = ["a","b","c"]14 c = a + b #列表相加

15 print(c, "输出两个列表相加后的c")16 d = a * 4 #乘

17 print(d, "输出乘4后的a")18 n = 8

19 x = n in l #判断元素是否存在与列表中，x值一定是布尔值

20 print(x)21 print(n ina)22 print(n not in l)

-遍历：for,while

-双层列表/嵌套列表

1 a = [["one", 1], ["two", 2], ["three", 3]]2 for k,v ina:3 print(k, "-->", v)4

5 a = [["one", 1, "一"], ["two", 2, "二"], ["three", 3, "三"]]6 for k,v,w ina:7 print(k, "-->", v, "-->", w)

-列表内涵：list content

1 a = [1,2,3,4,5,"a"]2 b = [i*10 for i ina]3 print(b)4

5 a = [x for x in range(1,35)]6 #过滤原来列表的内容

7 b = [m for m in a if m % 2 ==0]8 print(b)9

10 a = [x for x in range(1,10)]11 print(a)12 b = [y for y in range(100,400) if y % 100 ==0]13 print(b)14 #列表生成可以嵌套

15 c = [m+n for m in a for n inb]16 print(c)17 #等价于

18 for m ina:19 for n inb:20 print(m+n, end=" ")21 print()22

23 c = [m+n for m in a for n in b if m+n < 250]24 print(c)

-求列表长度：len(l)；　　最大值：max(l)；最小值：min(l)；强制转换：list(l)；清空：l.clear()；翻转：l.reverse()；拼接：l1.extend(l2)；查找列表中指定元素的个数：l.count(8)；查看指定值的位置：x=l.index(8)

-拷贝

-浅拷贝：l2=l1.copy()，传值，只拷贝一层

-深拷贝：待续

1 a = [1,2,3,[4,5,6]]2 b =a.copy()3 print(id(a))4 print(id(b)) #id(a)和id(b)不同

5 print(id(a[3][2]))6 print(id(b[3][2])) #id(a[3][2)和id([3][2)相同

-set(集合)

-元素无序，唯一不重复

-集合的定义

1 s =set()2 s = {1,2,3,4,5,6,7}3 print(type(s), s)

-用法

-成员检测：in，not in

-向集合添加元素：add：s.add(“a”)；移除集合中指定的值：s.discard(1100)，删除不存在的值时不报错；随机移除一个元素：s.pop()；

1 s1 = {1,3,"a",5,6,7,8,9}2 s2 = {1,3,"a",536,987,7}3 s_i =s1.intersection(s2)4 print("交集：", s_i)5

6 s_d =s1.difference(s2)7 print("差集：", s_d)8

9 s_u =s1.union(s2)10 print("并集：", s_u)11

12 s_isub =s1.issubset(s2)13 print("检查一个集合是否为另一个子集：", s_isub)14

15 s_isup =s1.issuperset(s2)16 print("检查一个集合是否为另一个超集：", s_isup)

-集合内涵

-自动过滤重复元素

-很多用法同list

-forzerset：冰冻集合：不能进行修改的集合，一种特殊集合

-dict(字典)

-无顺序的数据组合，以键值对形式出现

1 d = {"one":1, "two":2, "three":3}

-常见操作

1 d = {"one":1, "two":2, "three":3}2 print(d["one"]) #访问键值

3 d["one"] = "一" #根据键修改值

4 print(d["one"])5 del d["one"] #删除

6 print(d)7 if "two" in d: #成员检测，检测的是键

8 print("key")9 for k in d: #根据键访问键和值

10 #for k in d.keys(): #同上

11 print(k,d[k])12

13 for v in d.values(): #只访问值

14 print(v)15

16 for k,v in d.items(): #不可以直接使用d，要用items表示键值对

17 print(k, "-->", v)18

19 print(d.get("ddse",18)) #根据指定键去值，键不存在不报错返回None，如果指定默认值(18)，则返回默认值

20

21 #特殊函数fromkeys

22 l = ["a", "b", "c"]23 d = dict.fromkeys(l, "666") #只有两个参数，所有的键有相同的值

24 print(d)

-其他用法和list类似

-tuple(元组)

-元组可以看成不可以更改的list，可访问等

-创建一个只有一个值的元组：t = (1,)，注意要有逗号(有无括号均可)

-两个变量交换值：a,b = b,a