python-变量作用域和列表

最新推荐文章于 2022-10-28 23:45:17 发布

dc308308

最新推荐文章于 2022-10-28 23:45:17 发布

阅读量360

点赞数

#变量作用域

-变量由作用范围限制

-分类：按照作用域分类

·全局（global）：在函数外部定义

·局部（local）：在函数内部定义

-变量的作用范围：

·全局变量：在整个全局范围都有效

·全局变量在局部可以使用

·局部变量在局部范围可以使用

·局部变量在全局范围无法使用

-LEGB原则

·L（local）局部作用域

·E（Enclosing function locale）外部嵌套函数作用域

·G（Global module）函数定义所在模块作用域

·B（Buildin）:python内置魔抗的作用域

a1=100
def fun():
    print(a1)
    print("I am fun")
    a2=99
    print(a2)

print(a1)
fun()

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

-使用global

def fun():
    global b1,b2
    b1=100
    print(b1)
    print("I am fun")
    b2=99
    print(b2)

print(b1)
print(b2)
fun()

#globals和locals

a=1
b=2

def fun(c,d):
    e=111
    print("locals={0}".format(locals()))
    print("globals={0}".format(globals()))


fun(100,200)

#eval（）函数

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

-语法：

eval（string_code,globals=None,locals=None）

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

#exec（）函数

-跟eval（）函数功能类似，但是不返回结果

-语法：

exec（string_code,globals=None,locals=None）

x=200
y=100
z1=x+y
z2=exec("print('x+y':x+y)")
print(z1)
print(z2)

#递归函数

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

-优点：简洁，理解容易

-缺点：对递归深度有限制，消耗资源大

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

-在写递归程序的时候，一定注意结束条件

#递归调用深度限制代码

x=0

def fun():
    global x
    x+=1
    print(x)
    #函数自己调用自己
    fun()

#调用函数
fun()

#斐波那契数列

def fib(n):
    if n==1:
        return 1
    if n==2:
        return 1

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


print(fib(3))
print(fib(10))

#内置数据结构（变量类型）

-list

·一组有顺序的数据的组合

·创建列表

-空列表

#1.创建空列表
l1=[]
print(type(l1))
print(l1)

#2.创建带值的列表
l2=[100]
print(type(l2))
print(l2)

#3.创建列表，带多个值
l3=[2,3,1,5,6,4,6]
print(type(l3))
print(l3)

#使用list()
l4=list()
print(type(l4))
print(l4)

#列表常用操作

-访问

·使用下标操作（索引）

·列表的位置是从0开始

-分片操作

·对列表进行任意一段的截取

·l[:]

l=[3,2,1,4,6,3,2]
print(l[3])
print(l[0])

#分片操作
#下标值可以为空，如果不写，左边下标值默认为0
print(l[:])
print(l[:4])
print(l[2:])
print(l[1:4])

#分片可以增长幅度
print(l)
print(l[1:6:1])
print(l[1:6:2])
print(l[2:10])


#分片之负数下标
print(l)
print(l[-2:-4])
print(l[-4:-2])
print(l[-2:-4:-1])

分片操作是生成一个新的list

-内置函数id，负责显示一个变量或者数据的唯一确定编号

#id函数举例
a=100
b=200
print(id(a))
print(id(b))

c=a
print(id(c))

a=101
print(a)
print(c)

l=[3,4,56,76,32,21,43,5]
ll=l[:]
lll=ll
print(id(l))
print(id(ll))
print(id(lll))


ll[1]=100
print(ll)
print(lll)

while循环访问list一般不用while循环遍历list

a=[1,2,3,4,5,6]
length=len(a)
#indx表示的是list的下标
indx=0
while indx<length:
    print(a[indx])
    indx+=1

#双层列表循环

#a为嵌套列表，或者叫做双层列表
a=[["one",1],["two",2],["three",3]]

for k,v in a:
    print(k,"---",v)

#列表内涵：list content

#for创建
a=['a','b','c']
#用list a创建一个list b
b=[i for i in a]
print(b)


a=[1,2,3,4,5]
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,b
a=[i for i in range(1,4)]
print(a)

b=[i for i in range(100,400) if i%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()

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



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)

#关于列表的参数

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

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


#insert:指定位置插入
#insert(index data)插入位置是index前面

print(a)
a.insert(3,666)
print(a)


#del删除
#pop从对位拿出一个元素，即把最后一个元素取出来

print(a)
last_ele=a.pop()
print(last_ele)
print(a)


#remove在列表删除指定的元素
#删除list指定值的操作应该使用try...excepty语句，或者先行进行判断

print(a)
print(id(a))
a.remove(3)
print(a)
print(id(a))


#clear：清空
print(a)
print(id(a))
a.clear()
print(a)
print(id(a))


#reverse:翻转

a=[1,2,3,4,5]
print(a)
print(id(a))


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

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

a.extend(b)

print(a)
print(id(a))


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

print(a)
a.append(8)
a.insert(4,8)
print(a)
a_len=a.count(8)
print(a_len)


#copy:拷贝，浅拷贝
#列表类型变量赋值示例
a=[1,2,3,4,5,666]
print(a)
#list类型，简单赋值操作，是传地址
b=a
b[3]=777
print(a)
print(id(a))
print(b)
print(id(b))

print("*"*28)

b=a.copy()
print(a)
print(id(a))
print(b)
print(id(b))

print("*"*30)
b[3]=888
print(a)
print(b)

#深拷贝和浅拷贝的区别
a=[1,2,3,[10,20,30]]
b=a.copy()
print(id(a))
print(id(b))
print(id(a[3]))
print(id(b[3]))
a[3][2]=666
print(a)
print(b)

-set

#len,max,min:跟其他基本函数一致
s={43,23,56,223,4,2,1222,1,323,1}
print(len(s))
print(max(s))
print(min(s))

#set:生成一个集合
l=[1,2,3,4,3,23,1,2,3,4]
set=set(l)
print(s)

#clear
s={1,2,3,4,5}
print(id(s))
s.clear()
print(id(s))

#copy：拷贝

#remove：移除指定的值，直接改变原有值，如果要删除的值不存在，报错

#discard：移除集合中指定的值，跟remove一样，但是如果要删除的话，不报错

s={23,3,4,5,1,2,3}
s.remove(4)
print(s)
s.discard(1)
print(s)

print("*"*20)
s.discard(1100)
print(s)

s.remove(1100)
print(s)

#pop随机移除一个元素
s={1,2,3,4,5,6,7}
d=s.pop()
print(d)
print(s)

#集合函数

#intersection：交集

#difference：差集

#union：并集

#issubset：检查一个集合是否为另一个子集

#issuperset：检查一个集合是否为另一个交集

s1={1,2,3,4,5,6}
s2={5,6,7,8,9}

s_1=s1.intersection(s2)
print(s_1)
s_2=s1.difference(s2)
print(s_2)
s_3=s1.issubset(s2)
print(s_3)


#集合数学操作
s1={1,2,3,4,5,6}
s2={5,6,7,8,9}

s_1=s1-s2
print(s_1)

s_2=s1+s2
print(s_2)

#frozen set：冰冻集合

·冰冻就是不可以进行任何修改的集合

·frozen set是一种特殊集合

#创建

s=frozenset()
print(type(s))
print(s)

-dict

·字典是一种组合数据，没有顺序的组合数据，数据以键值对形式出现

#字典的创建
#创建空字典1
d={}
print(d)

#创建空字典2
d=dict()
print(d)

#创建有值的字典，每一组数据用冒号隔开，每一对键值对用逗号隔开
d={"one":1,"two":2,"three":3}
print(d)

#用dict创建有内容的字典1
d=dict({"one":1,"two":2,"three":3})
print(d)

#用dict创建有内容的字典2
#利用关键字参数
d=dict( one=1,two=2,three=3)
print(d)


#
d=dict({( "one",1),("two",2),("three",3)})
print(d)

#字典的特征

·字典是序列类型，但是是无序序列，所以没有分片和索引

·字典中的数据每个都有键值对组成，即kv对

·key：必须是可哈希的值，比如int，string，float，tuple但是list，set，dict不行

·value：任何值

#字典常见操作

#访问数据
d={"one":1,"two":2,"three":3}
#注意访问格式
#中括号内是键值
print(d["one"])

d["one"]="eins"
print(d)

#删除某个操作
#使用del操作
del d["one"]
print(d)

#成员检测只检测的是key内容
d={"one":1,"two":2,"three":3}
if 2 in d:
    print("value")
if "two" in d:
    print("key")
if ("two",2) in d:
    print("kv")


#使用for循环，直接按key的值访问
d={"one":1,"two":2,"three":3}
for k in d:
    print(k,d[k])

for k in d.keys():
    print(k,d[k])

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

for k,v in d.items():
    print(k,'--',v)

#字典生成式

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

#常规字典生成式
dd={k:v for k,v in d.items()}
print(dd)

#加限制代码条件的字典生成式
dd={k:v for k,v in d.items() if v%2==0}
print(dd)

#字典相关函数

#通用函数：len,max,min,dict
#str(字典)：返回字典的字符串格式
d={"one":1,"two":2,"three":3}
print(str(d))

#clear:清空字典
#items:返回字典的键值对组成的元组格式
d={"one":1,"two":2,"three":3}
i=d.items()
print(type(i))
print(i)

#keys：返回字典的一个键组成的一个结构
k=d.keys()
print(type(k))
print(k)


#values:同理，根据指定键返回相应的值，好处是，可以设置默认值
d={"one":1,"two":2,"three":3}
print(d.get("on333"))

#get默认值是None，可以设置
print(d.get("one",100))
print(d.get("one333",100))

#fromkeys:使用指定的序列作为键，使用一个值作为字典的所有的值
l=["1","2","3"]
#注意两个参数的类型
#注意fromkeys的调用主体
d=dict.fromkeys(l,"hhhhh")
print(d)

-tuple

·元组可以看成是一个不可更改的list

#创建空元组
t=()
print(type(t))

#创建一个只有一个值的元组
t=(1,)
print(type(t))
print(t)

t=1,
print(type(t))
print(t)


#创建多个值的元组
t=(1,2,3,4,5)
print(type(t))
print(t)

#使用其他结构创建
l=[1,2,3,4,5,6]
t=tuple(l)
print(type(t))
print(t)

#元组的特性

·是有序列表，有序

·元组数据值可以访问，不能修改

·元组数据可以是任意类型

·总之，list所有特性，除了可修改之外，元组都具有

#索引操作
t=(1,2,3,4,5)
print(t[4])


t=(1,2,3,4,5,6)
t1=t[1:2]
print(id(t))
print(id(t1))
print(t1)

#切片可以超标
t2=t[2:100]
print(t2)

#序列相加
t1=(1,2,3)
t2=(5,6,7)
#传址操作
t1=t1+t2
print(t1)
print(id(t1))


#元组相乘
t=(1,2,3)
t=t*3
print(t)

#成员检测
t=(1,2,3)
if 2 in t:
    print("yes")
else:
    print("no")


#元组遍历，一般采用for
#1.单层元组遍历
t=(1,2,3,"dudu","i","love")
for i in t:
    print(i,end=" ")
#2.双层元组的遍历
t=((1,2,3),(2,3,4),("dudu","i","love"))
for i in t:
    print(i)
for k,m,n in t:
    print(k,'---',n)