Python基础3

变量作用域

全局(global): 在函数外部定义，局部内可使用
局部（local)：在函数内部定义，局外不能使用
提升局部变量为全局变量
使用global

  def fun():  
      global x
     
print("Locals={0}".format(locals()))#显示局部变量
print("Globals={0}".format(globals()))#显示全局变量

eval()函数

把一个字符串当成一个表达式来执行， 返回表达式执行后的结果

exec()函数

不返回结果

x = 100
y = 200
z1 = x + y
# 1, 注意字符串中引号的写法
# 2. 比对exec执行结果和代码执行结果
z2 = exec("print('x+y:', x+y)")
z3=eval("x+y")

print(z1)
print(z2)
print(z3)
=>
x+y: 300
300
None
300

list

创建列表、分片操作

l1 = []
l2 = [100]
l3 = [2,3,1,4,6,4,6]
l4 = list()
print（l3[3]）=> 4  #下标从0 开始
# 分片操作
# 注意截取的范围，包含左边的下标值，！！不包含右边的下标值！！
# 下标值可以为空，如果不写，左边下标值默认为0， 右边下标值为最大数加一，即表示截取到最后一个数据
print(l[1:4])=>[3,1,4]
print(l[:])=>[2,3,1,4,6,4,6]
print(l[:4])=>[2,3,1,4]
print(l[2:])=>[1,4,6,4,6]
# 分片可以控制增长幅度，默认增长幅度为1
print(l[1:6:1])=>[3,1,4,6,4]
# 打印从下标1开始的数字，每次隔一个
print(l[1:6:2])=>[3,4,4]
# 下标可以超出范围，超出后不在考虑多余下标内容
print(l[2:10])=>[1,4,6,4,6]
# 下标值，增长幅度可以为负数
# 为负数，表明顺序是从右往左 #规定： 数组最后一个数字的下标是-1
print(l[6:0:-1])=>[6,4,6,4,1,3]
# 即正常情况，分片左边的值一定小于右边的值
print(l[-3:-5])=>[]
print(l[-5,-3])=>[1,4]
# 如果分片一定左边值比右边大，则步长参数需要使用负数
# 此案例为一个list直接正反颠倒提供了一种思路
print(l[-3,-5,-1])=>[6,4]

分片操作是生成一个新的list
内置函数id，负责显示一个变量或者数据的唯一确定编号,通过print（id（l2））来看l2和l3的区别，是否为同一份数据；
通过id可以直接判断出分片是重新生成了一份数据还是使用的同一份数据
答案是分片是重新生成一份数据
直接ll=l 赋值的话是使用同一份数据

l = [3,4,56,76,32,21,43,5]
ll = l[:]  #l 与ll、lll不同
lll = ll   #ll与lll共同用一份数据
l[1] = 100
print(l)=>[3, 100, 56, 76, 32, 21, 43, 5]
print(ll)=>[3, 4, 56, 76, 32, 21, 43, 5]
ll[1] = 100
print(ll)=>[3, 100, 56, 76, 32, 21, 43, 5]
print(lll)=>[3, 100, 56, 76, 32, 21, 43, 5]

del: 删除命令
没有生成新的list，是原来基础上修改

a = [1,2,3,4,5,6]
del a[2]
print(a)=>[1,2,4,5,6]

列表相加,乘,是否在表内

a=[1]
b=[2]
c=a+b
print(c)=>[1,2]
d=c*2
print(d)=>[1,2,1,2]
print(b in d)=>True

list的遍历

a = [1,2,3,4,5]
for i in a:
    print(i)

嵌套列表

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

列表内涵: list content

a = ['a', 'b', 'c']
b = [i for i in a]
c=[i*10 for i in a]#每个数据再乘10
a=[i for i in range(1,4)]=>[1,2,3]
b = [i for i in range(100,400) if i % 100 == 0]=>[100,200,300]
c = [  m+n for m in a for n in b]=>[101, 201, 301, 102, 202, 302, 103, 203, 303]

    # 上面代码跟下面代码等价
for m in a:
    for n in b:
        print(m+n, end="  ")



len(a)#长度
max(a)#最大值
s = "I love"
print(list(s))=>['i',' ,' ','l','o','v','e']#将其他格式的数据转换成list

传值和传地址的区别
对于简单的数值，采用传值操作，即在函数内对参数的操作不影响外面的变量
对于复杂变量，采用传地址操作，此时函数内的参数和外部变量是同一份内容，
任何地方对此内容的更改都影响另外的变量或参数的使用
list传的是地址，是整个数据，会随着改变

def a(n):
    n[2] = 300
    print(n)
    return None 
def b(n):
    n += 100
    print(n)
    return None
an = [1,2,3,4,5,6]
bn = 9
print(an)
a(an)
print(an) 
print(bn)
b(bn)
print(bn)
=>[1, 2, 3, 4, 5, 6]
[1, 2, 300, 4, 5, 6]
[1, 2, 300, 4, 5, 6]
9
109
9

append 插入一个内容, 在末尾追加

a=[i for i in range(1,5)]
a.append(100)
print(a)=>[1,2,3,4,100]

insert(index, data), 插入位置是index前面

a.insert(3,666）
print(a)=>[1,2,3,666,4,100]

pop，从对位拿出一个元素，即把最后一个元素取出来,出栈

last_ele = a.pop()
print(last_ele)=>100
print(a)=>[1,2,3,666,4]

remove:在列表中删除指定的值的元素,在原list直接操作

if 666 in a:
    a.remove(x)
print(a)=>[1,2,3,4]

clear:清空

a.clar
print(a)=>[]
#如果不需要列表地址保持不变，则清空列表可以使用以下方式
a=list()
a=[]

reverse:翻转列表内容，原地翻转

a=[1,2,3,4]
a.reverse()
print(a)=>[4,3,2,1]

extend:扩展列表，两个列表，把一个直接拼接到后一个上

a = [ 1,2,3,4,5]
b = [6,7,8,9,10]
a.extend(b)
print(a)=>[1,2,3,4,5,6,7,8,9,10]

count:查找列表中指定值或元素的个数

a=[1,2,3,3,3,4]
print(a.count(3))=>3

copy: 拷贝，此函数是浅拷贝
list赋值需要采用copy函数

a=[1,2,3,4]
b=a.copy()
b[2]=100
print(b)=>[1,2,100,4]
printf(a)=>[1,2,3,4]#原数据不变

深拷贝跟浅拷贝的区别
出现下列问题的原因是，copy‘函数是个浅拷贝函数，即只拷贝一层内容

 a = [1,2,3, [10, 20, 30]]
b = a.copy()
#双层函数就不行了，
a[3][2]=100
print(a)=>[1, 2, 3, [10, 20, 666]]
print(b)=>[1, 2, 3, [10, 20, 666]]