py2和py3的区别
线上操作系统：centos
每种数据类型，列举你知道的方法。
3 or 9 and 8
字符串的反转
is 和 == 的区别
v1 = (1) / v2 = 1
深浅拷贝
文件操作，大文件如何读取内容【50G的日志文件】
v = open(...)
for line in v:
print(line)
v.close()函数基本结构
def func(name,age,email):
#函数体(保持缩进一致)
a = 123
print(a)
return 8 #一旦遇到return后面代码就不执行
b = 456
print(b)
m = func(1,2,3)
#定义函数时设置了参数，调用时一定要写参数，设置了几个就写几个。参数
def func(n1,n2):
print(n1,n2)
func(1,2)
func([1,2],{a:1,b:2})
#严格按照顺序传参数：位置方式传参。
#实际参数可以是任意类型。返回值
函数没有返回值时，默认返回None。
函数内部执行过程中遇到return，则终止。
def fun():
return '完成' #函数每次执行到此就返回，下面代码永远不执行。
for i in range(10):
print(i)
fun()
def fun():
for i in range(10):
print(i)
return '完成'
fun() #调用时只会打印0return可以返回任意类型。
def fun():
return (1,2,3)
v = fun()
print(v)
#特殊：返回元组
def fun():
return 5,8,'alex'
v = fun()
print(v)
def func(x):
v = x[1::2]
return list(v)
v1 = func([1,2,3])
v2 = func((1,2,3))
#其它类型可以通过list(type)强制转换成列表
dic = {'k1':1,'k2':2}
lst = list(dic)
print(lst)
['k1','k2']
#字典转列表，默认是循环keydef sum(data):
v = True if len(data) > 5 else False
return v
msg = input('>>>')
print(sum(msg))
def sum(a,b):
return a if a - b > 0 else b
msg = sum(11,2)
print(msg)def func(name,gender,age,edu):
# template = '%s*%s*%s*%s'%(name,gender,age,edu,)
# return template
lst = [name,gender,age,edu]
return '*'.join(lst)
a = input('>>>')
b = input('>>>')
c = input('>>>')
d = input('>>>')
result = func(a,b,c,d)
print(result)def fun(max):
lst = []
while True:
if len(lst) == 0:
lst.append(1)
if len(lst) == 1:
lst.append(1)
else:
n = lst[-1] + lst[-2]
if n > max:
break
lst.append(n)
return lst
fun(300)#写函数验证用户名是否在文件中，如果存在返回True，不存在返回False。
#函数有一个参数，用于接收用户输入的用户名。
'''文件格式
1|alex|123123
2|eric|rewrew
3|wupeiqi|ppp
'''
方式一
def fun(name):
with open('文件操作练习.txt', mode = 'r',encoding = 'utf-8') as obj:
content = obj.read()
flag = False
row_list = content.split('\n')
for row in row_list
v = row.split('|')
if v[1] == name:
flag = True
return flag
方式二
def fun(name):
with open('文件操作练习.txt', mode = 'r',encoding = 'utf-8') as obj:
content = obj.read()
row_list = content.split('\n')
for row in row_list
v = row.split('|')
if v[1] == name:
return True
v = func('alex')
if v:
print('存在')
else:
print('不存在')基本的参数知识
def func(a,b,c,d):
print(a,b,c,d)
func(1,'alex',True)位置传参（调用函数并传入参数）
def func(a1,a2):
print(a1,a2)
func(1,2)
#定义了几个参数，调用时就传入几个参数，每个实际参数和形式参数一一对应。关键字传参
def func(a1,a2):
print(a1,a2)
func(a1=6,a2=66)
func(a2=66,a1=6)
#调用函数时写上定义函数所设置的参数名字，就可以任意换位了。
def func(a1,a2,a3):
print(a1,a2,a3)
func(1,6,a3=9)
func(1,a2=6,a3=9)
#位置传参和关键词传参可以混合使用。
func(a1=1,6,9)
#混合使用时，需要保证位置参数在前，关键字参数在后，不然会报错。
func(1,a1=6,a3=9)
#会先处理位置参数再处理关键字参数，这样会因参数多值而报错。默认参数（定义）
def func(a1,a2=9)
print(a1,a2)
func(1)
#func函数可以接受两个参数，再调用函数进行传值时可以只传一个参数，另个参数使用默认值。
def func(a1,a2,a3=6,a4=9):
print(a1,a2,a3,a4)
func(1,2)
func(1,2,3)
func(1,2,3,4)
func(1,2,3,a4=4)
func(1,2,a=3,4) #报错，关键字传参一定要放在位置传参后面。万能参数（打散）
情况1
def func(*a): # 一般写成*args，潜规则
print(a)
func(1) # 结果是元组(1,)
func(1,2,[3,4],567,'alex')
func((1,2,3)) # ((1, 2, 3),)
func(*(1,2,3)) # (1, 2, 3)
情况2
def func(a1,*args):
print(a1,args)
func(1,2,3)
func(a1=1,2,3) # 报错，关键字永远在位置参数后。
情况3：基本遇不到
def func(a1=3,*args,a2=6):
print(a1,args,a2)
func(1,2,3) # a1的默认值永远会被覆盖，a2不用关键字传参永远默认值。
func(a1=1,2,3,a2=4) # 报错，关键字永远在位置参数后。
func(1,2,3,a2=4)def func(**kwargs):
print(kwargs)
func(a=1,b='alex') # 只能用关键字传参
#结果{'a': 1, 'b': 'alex'}
def func(**v):
print(v)
func(**{'a':11,'b':'eric'})
#结果{'a': 11, 'b': 'eric'}def func(*args,**kwargs)
print(args,kwargs)
func(1,2,3)
func(1,2,3,k1=4,k2=5,k3=6)
func(*[1,2,3],**{'k1':4,'k2':5})
func(11,22,*[1,2,3],k0='a',**{'k1':4,'k2':5})
#(1, 2, 3) {}
#(1, 2, 3) {'k1': 4, 'k2': 5, 'k3': 6}
#(1, 2, 3) {'k1': 4, 'k2': 5}
#(11, 22, 1, 2, 3) {'k0': 'a', 'k1': 4, 'k2': 5}参数相关的重点：
def func1(a1,a2):
pass
def func2(a1,a2=None):
pass
def func3(*args,**kwargs):
passPython中：
py文件：全局作用域
函数：局部作用域
a = 1
def s1():
x1 = 666
print(x1)
print(a)
print(b)
#def s3():
#pass
#s1()如果在此位置会报错，因为代码执行此时还未定义b。
b = 2
print(a)
s1()
a = 888
def s2():
print(a,b)
s1() #s2()内部可以调用已经出现在全局的s1()，但是无法调用嵌套在s1()中的函数s3()。
s2()总结：
一个函数是一个作用域（其它语言并非一样）
def func():
x = 9
print(x)
func()
print(x) #会报错作用域查找数据规则：优先在自己的作用域找数据，自己没有就去上一级作用域寻找数据一直到全局，全局若没有就会报错。
x = 10
def fun():
x = 8 #如果此行没有，结果会是10。
print(x)
func() #结果是8。注意父级作用域中的值是否发生变化。
#示例
x = 10
def func():
x = 9
print(x)
def func2():
x = 8
print(x)
func()
#示例
x = 10
def func():
x = 9
print(x)
def func2():
x = 8
print(x)
func2()
func()
#示例
x = 10
def func():
x = 9
print(x)
def func2():
x = 8
print(x)
print(x)
func2()
func()
#示例
x = 10
def func():
x = 9
print(x)
def func2():
x = 8
print(x)
func2()
print(x)
func()
#示例
x = 10
def func():
x = 9
print(x)
def func2():
print(x)
func2()
print(x)
func()
#示例
x = 10
def func():
x = 9
print(x)
def func2():
print(x)
x = 10
func2()
x = 11
print(x)
func()
#示例
x = 10
def func():
x = 9
print(x)
def func2():
print(x)
func2()
x = 10
func2()
x = 11
print(x)
func()子作用域中只能找到父级作用域中的变量的对应值，默认无法重新为父级作用域中的变量重新赋值。
name = 'oldboy'
def func():
name = 'alex'
print(name)
func() #alex
print(name) #oldboy
lst = [1,2,3]
def func():
lst.append(888)
print(lst)
func() #[1,2,3,888]并没有重新赋值，而是对可变类型数据修改。golbal关键字，强制改变全局作用域中的变量值。
#如果非要对全局变量重新赋值，采用golbal关键字
data = '加油'
def func():
global data
data = '中国'
func()
print(data)
data = '加油'
def func():
data = '中国'
def func2():
global data
data = ['四川']
func2()
print(data)
func()
print(data)nonlocal关键字，强制改变父级作用域中的变量值。
data = '加油'
def func():
data = '中国'
def func2():
nonlocal data
data = ['四川']
func2()
print(data)
func()
print(data)原文：https://www.cnblogs.com/elliottwave/p/12521805.html