python基础知识汇总

https://www.liujiangblog.com/course/python/1
顺序执行

python代码执行过程
。普通语句，直接执行
。碰到函数，将函数体载入，并不直接执行
。碰到类，执行类内部的普通语句，但是类的方法只载入，不执行
。碰到if、for等控制语句，按相应控制流程执行
。碰到@，break，continue等，按规定语法执行
。碰到函数、方法调用等，转而执行函数内部代码，执行完毕继续执行原有顺序代码

if name ==“main”:

函数

参数

一、位置参数
必传参数，顺序参数，调用函数时明确提供的参数，位置参数必须按先后顺序，一一对应，个数不多不少的传递

二、默认参数
函数定义时，参数中有默认参数，可以给默认参数传值也可以不传值直接使用默认参数

1、默认参数必须放在位置参数的后面
2、多个默认参数时，将变化多的放前面，变化少的放后面
3、在调用函数时，尽量给实际参数提供默认参数名
4、传参使用位置参数的参数名，可不按先后顺序
5、默认参数尽量指向不变的对象 （a=[] 可变对象）

三、动态参数（可变化个数的参数）
动态参数 *args **kwargs
动态参数必须放在位置参数和默认参数的后边
*args 一个星号代表接收任意个参数
def func(*args):
for arg in args:
print(arg)

li = [1, 2, 3]
func(li) #[1, 2, 3] 将li作为一个参数传入

def func(*args):
for arg in args:
print(arg)

li = [1, 2, 3]
func(*li) # 1 2 3 带一个*将li内的1，2，3分别传入

**kwargs

两个星表示接受键值对的动态参数，数量任意。调用的时候会将实际参数打包成字典

def func(**kwargs):
for kwg in kwargs:
print(kwg, kwargs[kwg])

dic = {
‘k1’: ‘v1’,
‘k2’: ‘v2’
}

func(**dic) #使用两个*号

万能参数

def func(*args, **kwargs): #万能参数

for arg in args:
    print(arg)

for kwg in kwargs:
    print(kwg, kwargs[kwg])

lis = [1, 2, 3]
dic = {
‘k1’: ‘v1’,
‘k2’: ‘v2’
}

func(*lis, **dic)

变量作用域：变量的有效范围

1、python中if for with 是没有作用域的概念的

函数内部的变量无法被函数外部访问，类内部的变量可以被类内部访问，无法被外部访问
总结：内部可以访问外部，外部不能访问内部

python作用域分为4层
全局作用域 G
局部作用域 L
闭包函数外的函数中 E
内建作用域 B

L->E ->G->B 按照这个顺序python查找作用域

global：指定当前变量使用外部的全局变量

total = 0 # total是一个全局变量

def plus( arg1, arg2 ):
global total # 使用global关键字申明此处的total引用外部的total
total = arg1 + arg2
print("函数内局部变量total= ", total)
print("函数内的total的内存地址是: ", id(total))
return total

plus(10, 20)
print("函数外部全局变量total= ", total)
print("函数外的total的内存地址是: ", id(total))

函数内局部变量total= 30
函数内的total的内存地址是: 503494624
函数外部全局变量total= 30
函数外的total的内存地址是: 503494624

a = 1
print("函数outer调用之前全局变量a的内存地址： ", id(a))
def outer():
a = 2
print("函数outer调用之时闭包外部的变量a的内存地址： ", id(a))
def inner():
nonlocal a # 注意这行
a = 3
print("函数inner调用之后闭包内部变量a的内存地址： ", id(a))
inner()
print("函数inner调用之后，闭包外部的变量a的内存地址： ", id(a))
outer()
print("函数outer执行完毕，全局变量a的内存地址： ", id(a))

函数outer调用之前全局变量a的内存地址： 497726528
函数outer调用之时闭包外部的变量a的内存地址： 497726560
函数inner调用之后闭包内部变量a的内存地址： 497726592
函数inner调用之后，闭包外部的变量a的内存地址： 497726592
函数outer执行完毕，全局变量a的内存地址： 497726528

面试题：
name =‘jack’

def f1():
print(name)

def f2():
name = ‘eric’
f1()

f2()

最后打印的是jack
原因是函数在执行的时候不看调用位置的作用域，看实际函数在整个代码中所处的位置

range()
range()和切片 #都是遵从左开右闭
range(10) #可以遍历0-9
range(0,10) #遍历0-9
range(0,10,2) #遍历0-9 以2为步长
range(0,10,-1) #该用法不会报错但没有任何意义，步长是负数的时候区间必须从大到小和切片特性一致
range(10,1,-1) #反转
range(10,1) #该用法不会报错但没有任何意义

递归函数
1、可遍历某个目录下的所有文件和文件夹
2、可删除某个目录下的所有文件和文件夹
import os

#删除目录下的所有文件
project_path = os.path.split(os.path.split(file)[0])[0]
file = os.path.join(project_path,‘file’)
print (file)

def rm (file):
print (‘传入路径’,file)
if os.path.isdir(file):
file_name = os.listdir(file)
print (“file_name”,file_name)
if len(file_name) == 0:
print (“file下没有文件:删除”,file)
os.rmdir(file)
else:
for i in file_name:
path = os.path.join(file,i)
print (“绝对路径”,path)
if os.path.isdir(path) or os.path.isfile(path):
print(“传入路径path”,path)
rm(path)
print(“")
else:
continue
if os.path.isdir(file):
print(“传入路径file”,file)
rm(file)
print("**”)
else:
continue

else:
    print ("删除的是文件不是文件夹:",file)
    os.remove(file)

rm (‘F:\file’)

匿名函数
lambda 参数:表达式
匿名函数只能有一个表达式，不支持return语句，表达式的结果就是返回值
lambda不会带来程序运行效率的提高，只会使代码更简洁
foo=[1,2,3,4,5,67,8,9,0,12,23,45,56,25]
map(lambda x : x*2+10,foo)
filter(lambda x : x%3==0,foo)
reduce(lambda x,y:x+y,foo)
students = [
{‘name’: ‘TOM’, ‘age’: 20},
{‘name’: ‘ROSE’, ‘age’: 19},
{‘name’: ‘Jack’, ‘age’: 22}
]
students.sort(key=lambda x:x[‘name’],reverse=True)

推导式
1、列表推导式
lis = [xx for i in range(1,10)]
lis = [xx for i in range(1,11) if x % 2 == 0]
lis = [a+b for a in ‘123’ for b in ‘abc’]

2、字典推导式
dic = {x:x**2 for x in (2,4,6)}

3、集合推导式
a = {x for x in ‘abravjksgtcggag’ if x not in ‘abc’}

4、元组推导式
tup = tuple(x for x in range(9))

5、迭代器(生成的是迭代器而非元组)
gen = (x for x in range(9))

迭代器：通过for循环遍历对象的每一个元素的过程
inter() next()
生成器
gen = (x for x in range(9))
yield 让函数变成生成器
def fibo():
n=10
count = 0
a=0
b=1
while True:
if count >n:
break
yield a
print (a)
a=b
b=a+b
count +=1

fib = fibo()
print(type(fib))
for i in fib:
print (i)

装饰器

def outer1(func):
print (“func1”,func)
def inner1(*args,**kwargs):
print(“认证成功”)
print (“func11”,func)
result = func(*args,**kwargs)
print(“日志添加成功”)
return result
return inner1

def outer2(func):
print (“func2”,func)
def inner2(*args,**kwargs):
print (“一条欢迎信息。。。。”)
print (“func22”,func)
result = func(*args,**kwargs)
print (“一条欢送信息”)
return result
return inner2

@outer1 f1 =inner1 func=inner2
@outer2 f1 = inner2 func = f1
def f1(name,age):
print ("%s正在链接业务部门1数据接口。。。。。" % name)

f1(“jack”,18)

多个装饰器时先进入离函数最近的装饰器，如例子中先进入outer2再进入outer1

def logging(level):
def wrapper(func):
def inner_wrapper(*args,**kwargs):
print("[{}]:enter function {}()".format(level,func.name))
func(*args,**kwargs)

    return inner_wrapper
return wrapper

@logging(level=‘INFO’) #等同于 f2 = logging(level=‘INFO’)(f2) logging(level=‘INFO’)会先执行
def f2 (name,age):
print("%s带参数的装饰器调取日志级别" % name)

f2(“wang”,18)