Python学习过程笔记整理（四）

变量作用域

-分类

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

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

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

　　-使用global

-globals,locals内建函数

 a = 1
 b = 2
 def fun(a,b):
     c = 3
     print("Locals = {0}".format(locals()))
     print("Globals = {0}".format(globals()))  #打印的不仅是a，b，还有其他所有的全局变量，包括python自带的
 fun(a,b)

-eval()、exec()函数

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

　　-语法

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

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

 x = 100
 y = 200
 z1 = eval("x+y")
 z2 = exec("x+y")
 print(z1)   #
 print(z2)   #None

 #以下eval和exec结果相同
 z1 = eval("print('x+y=:',x+y)")   #x+y=: 300
 z2 = exec("print('x+y=:',x+y)")   #x+y=: 300
 print(z1)    #None
 print(z2)    #None

-递归函数

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

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

 #斐波那契数列，只考虑正常输入的n
 def fib(n):
     if n == 1 or n ==2:
         return 1
     return fib(n-2) + fib(n-1)

 print(fib(5))

 # 汉诺塔程序，只考虑正常输入
 def hano(n, a, b, c):
     """
     汉诺塔的的递归实现
     :param n: 一共有n个盘子
     :param a: 起始塔
     :param b: 过渡塔
     :param c: 目标塔
     :return: None
     """
     if n == 1:
         #print(a, b, c, n,"*" * 30)  理解程序的调试语句
         print(a, "-->", c)
         return None
     if n == 2:     # 实际上该部分可以省略
         #print(a, b, c, n,"*" * 20)  理解程序的调试语句
         print(a, "-->", b)
         print(a, "-->", c)
         print(b, "-->", c)
         return None
     # 当n>=3时，把n-1个盘子借助c，从a移动到b上
     #print(a, b, c, n-1,"*" * 10) 理解程序的调试语句
     hano(n-1, a, c, b)
     print(a, "-->", c)
     # 而后把n-1个盘子，借助a，从b移动到c上
     hano(n-1, b, a, c)
     return None
 a = "A"
 b = "B"
 c = "C"
 n = 4
 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。注意：分片截取左边值比右边大时，步长注意需要使用负数

　　-一些常规操作

 l = [0,1,2,3,4,5,6]
 print(l, "输出原始l")
 last_ele = l.pop()  #取出最后一个元素
 print(last_ele, "输出取出的最后一个元素的值")
 print(l, "输出被取出最后一个元素以后的l")
 del l[2]     #删除制定index元素
 l.remove(0)   #删除指定的值
 print(l, "输出删除index为2，以及元素值为0后的l")
 l.append(2)     #追加元素
 l.insert(3,"a")   #插入元素，index前面
 print(l, "输出追加元素值为2，以及在index=3前面插入a的l")
 a = [7,8,9]
 b = ["a","b","c"]
 c = a + b    #列表相加
 print(c, "输出两个列表相加后的c")
 d = a * 4    #乘
 print(d, "输出乘4后的a")
 n = 8
 x = n in l #判断元素是否存在与列表中，x值一定是布尔值
 print(x)
 print(n in a)
 print(n not in l)

　　-遍历：for,while

　　-双层列表/嵌套列表

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

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

　　-列表内涵：list content

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

 a = [x for x in range(1,35)]
 # 过滤原来列表的内容
 b = [m for m in a if m % 2 ==0]
 print(b)

 a = [x for x in range(1,10)]
 print(a)
 b = [y for y in range(100,400) if y % 100 == 0]
 print(b)
 #列表生成可以嵌套
 c = [m+n for m in a for n in b]
 print(c)
 #等价于
 for m in a:
     for n in b:
         print(m+n, end="  ")
 print()

 c = [m+n for m in a for n in b if m+n < 250]
 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()，传值，只拷贝一层

　　　　-深拷贝：待续

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

-set（集合）

　　-元素无序，唯一不重复

　　-集合的定义

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

　　-用法

　　　　-成员检测：in，not in

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

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

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

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

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

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

　　-集合内涵

　　　　-自动过滤重复元素

　　-很多用法同list

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

-dict（字典）

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

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

　　-常见操作

 d = {"one":1, "two":2, "three":3}
 print(d["one"])  #访问键值
 d["one"] = "一"   #根据键修改值
 print(d["one"])
 del d["one"]  #删除
 print(d)
 if "two" in d:   #成员检测，检测的是键
     print("key")
 for k in d:       #根据键访问键和值
 #for k in d.keys():  #同上
     print(k,d[k])

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

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

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

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

　　-其他用法和list类似

-tuple（元组）

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

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

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