17-python知识点补充【小知识，面试中可能会考】

1、python的垃圾回收机制

Python中的垃圾回收是以引用计数为主，分代收集为辅。引用计数的缺陷是循环引用的问题。

在Python中，如果一个对象的引用数为0，Python虚拟机就会回收这个对象的内存。

2、变量的3大特性：id   type  value

3、input会把用户输入的所有值全部存储为：字符串类型

4、控制循环

while+break 跳出本层循环

while+continue  跳出本次循环，进行下一次循环

5、变量解压【掌握即可】

常规的：

salaries=[11,22,33,44]
s1=salaries[0]    s2=salaries[1]    s3=salaries[2]    s4=salaries[3]
s1,s2,s3,s4=salaries   #此时左边的个数必须=右边列表的长度

特殊的：

s1,s2,_,s4=salaries  #此时取出前2个和最后一个

s1,_,_,s4=salaries
s1,*_,s4=salaries  #这两种方法 都是取出前一个和最后一个

*_,s3,s4=salaries  #取出最后2个

注：*一般取列表（大列表）前几个和后几个数，对于取中间的，不建议使用*

6、数值类型转换

bin()  #把10进制转化为2进制      oct()  #把10进制转化为8进制       hex()  #把10进制转化为16进制 

7、常用的strip()、lower()、upper()、startswith()、endswith()、split()、join()、replace()、isdigit()

strip()  #默认去除空格，可以自己设置

name=input('请输入姓名：').strip()  #最常用的
msg='*****psy**'
print(msg.strip('*'))  #psy
print(msg)  #*****psy**

lower()  #全部大写      upper()全部小写

print('AbCdEf'.lower())  #abcdef
print('AbCdEf'.upper())  #ABCDEF

startswith()  #以什么开头     endswith()  #以什么结尾

print('psy'.startswith('p'))  #True
print('xk'.endswith('k'))  #True

split()  #按分割符把信息切分，存放在列表中     join()  #把列表组合成字符串

st='psy:name:age'
l=st.split(':')  #['psy', 'name', 'age']
res='*'.join(l)  #psy*name*age

replace(A,B,n)  #用B代替A，代替n次（一般情况下，若不指定n，则为全部替换）

msg='psy is a psy_star'
new_msg1=msg.replace('psy','xk')  #xk is a xk_star
new_msg2=msg.replace('psy','xk',1)  #xk is a psy_star

isdigit()  #表示该字符串是否是整数

print('10'.isdigit())  #True
print('5.55'.isdigit())  #False

8、利用列表（list）模拟队列和堆栈

（1）队列  先进先出                    （2）堆栈   先进后出

 

9、enumerate() 函数

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

goods=['apple','banana','pear']
for item in enumerate(goods):
    print(item)
'''
(0, 'apple')
(1, 'banana')
(2, 'pear')
'''

10、字典的更新update()  会覆盖

msg={'name':'psy','age':18}
msg.update({'age':24,'loaction':'NJ'})
print(msg)  #{'loaction': 'NJ', 'age': 24, 'name': 'psy'}

11、集合 set类型

定义在{ }内，用逗号分隔的元素

注意：1）集合中没有重复的元素  2）集合中的元素必须是不可变类型   ===>所以：集合可以去重，但是顺序会变！

空集合  s=set()

思考：想要去重，但是还要保证原来的顺序！        去重：集合   顺序：列表

l=['a','b',1,'a','a',2,1]
l_new=[]
s=set()
for item in l:
    if item not in s:
        s.add(item)
        l_new.append(item)
print(l_new)  #['a', 'b', 1, 2]

12、常见的列表套字典的排序

对下述列表分别按照字典中的age 和name 进行排序

l=[{'name':'psy','age':18},{'name':'pyg','age':55},{'name':'xk','age':24}]
l.sort(key=lambda item:item['age'])
print(l)  #[{'name': 'psy', 'age': 18}, {'name': 'xk', 'age': 24}, {'name': 'pyg', 'age': 55}]

l.sort(key=lambda item:item['name'])
print(l)  #[{'name': 'psy', 'age': 18}, {'name': 'pyg', 'age': 55}, {'name': 'xk', 'age': 24}]

13、字符编码问题

Unicode  内存中固定的编码（各国都在使用）     utf-8   硬盘上都是utf-8编码

【现阶段：内存上的编码是unicode，硬盘上的编码是utf-8，且内存上的编码不能更改】

保证不乱码的核心：文件是以什么形式编码存的，我们就以什么编码读取！

强调：我们能控制的只是存到硬盘上的编码，python3解释器：默认是utf-8编码

14、文件操作

（1）打开文件

f=open(r'文件路径',mode='打开文件的模式',encoding='编码'）       或者  with open(r'文件路径',mode='打开文件的模式',encoding='编码') as f

利用with的好处：不用关心f.close()       可以打开多个文件

（2）默认打开文件的编码

当前操作系统的编码：linux为utf-8    windows为gbk（一般都是自己设置为utf-8）

（3）操作文件的3种模式

r  默认的打开方式，只读模式    【注：当文件不存在时，报错】

w  只写模式  【注：当文件存在时，清空；当文件不存在时，创建空文档】

a  只追加写模式  【注：当文件存在时，光标直接跑到文件末尾；当文件不存在时，创建空文件】

补充：  b  常用于图片打开，但是不能单独使用，必须 rb,wb,ab    【注：b模式下一定不能指定编码！！！】

15、函数参数  【重点介绍：*args   **kwargs】

*  针对可变程度的位置参数    *将溢出的位置实参全部接受，然后保存成元组形式赋值给args    *args

**  针对可变程度的关键字实参    *将溢出的关键字实参全部接受，然后保存成字典形式赋值给kwargs    *kwargs

def f(x,y,*args):
    print(x,y,args)
f(1,2,3,4,5)  #1 2 (3, 4, 5)

def f(x,y,**kwargs):
    print(x,y,kwargs)
f(x=1,y=2,z=3,a=4,b=5)  #1 2 {'a': 4, 'b': 5, 'z': 3}

【注：一旦碰到实参加*   就把该实参打散，并用元组存放】

def f(x,y,z,*args):
    print(x,y,z)
    print(args)
f(1,2,3,*'hello')
"""
1 2 3
('h', 'e', 'l', 'l', 'o')
"""

重点：*与**的组合使用   （*args和**kwargs的组合使用）  【注：因为位置参数要在关键字参数之前，所以*args在**kwargs之前】  【！！！装饰器！！！】

def wrapper(*args,**kwargs):
    print(args)
    print(kwargs)
wrapper(1,2,3,4,5,x=1,y=2,z=3)
"""
(1, 2, 3, 4, 5)
{'x': 1, 'z': 3, 'y': 2}
"""

16、函数中的重点：【名称空间】【作用域】

名称空间：存放名字与值绑定关系的地方（3种）

（1）内置名称空间：存放python解释器自带的名字，在解释器启动时生效，在解释器关闭时失效    【比如：print   len  strip等等】

（2）全局名称空间：文件级别的名称（顶头写的，没有缩进），在执行文件时生效，在文件借宿或在文件执行期间被删除时失效

（3）局部名称空间：存放函数定义的名字（函数的参数以及函数内的名字都存放在局部名称空间），在函数调用时临时生效，函数结束时失效

加载顺序：内置名称空间===>全局名称空间===>局部名称空间

查找名字：局部名称空间===>全局名称空间===>内置名称空间    【重要！！！】

作用域

（1）全局作用域：包含的是内置名称空间与全局名称空间的名字

特点：任何位置都能够访问；该范围内的名字会伴随程序整个生命周期

（2）局部作用域：包含的是局部名称空间的名字

特点：只在函数内使用；调用函数时生效，调用结束失效。

【注：作用域关系是在函数定义阶段就规定死的，与调用函数无关】

【So无论函数在哪调用，都必须回到当初定义函数时的位置找作用域关系】

17、闭包函数   

（1）定义在函数内部的函数  （2）并且该函数包含对外部函数作用域中的名字的使用

【注：作用域在函数定义阶段就规定死了，与调用函数无关！！！】

def outter():
    name='psy'
    def inner():
        print('My name is {}'.format(name))
    return inner  #拿到闭包函数的内存地址
f=outter()
f()  #结果：My name is psy

【注：此时无论在哪调用f函数，结果都是“My name is psy”】

【注：闭包都是用于装饰器！！】

18、编写一个用户登录的小代码，要求：（1）最多输入3次用户名密码；（2）如果是被锁用户，则一次即退出程序；（3）如果输入正确的用户名密码，则提示登陆成功，程序结束；（4）3次输入不对，会将用户写入被锁用户列表，当然，该用户名需要是在注册用户列表中的。

print("***此程序用于验证用户登录。***")
print("***用户最多可输入3次用户名和密码。***")
print("***输入正确，有提示，不用输满3次，同一个用户名输入错误3次，会被锁***\n")
def checklock(name,lockfile):
    with open(lockfile,'r',encoding='utf-8')as fd:
        lockusername = fd.readlines()
        maxidx = len(lockusername) - 1
        i = 0
        while i <= maxidx:
            if name == lockusername[i].strip("\n"):
                print("用户被锁，请联系管理员")
                return True
            i+=1
        return False
def checkmatch(name,password,userfile):
    with open(userfile,'r',encoding='utf-8')as fd:
        line=fd.readline()
        while line:
            linedate = line.strip("\n").split(":")
            line=fd.readline()
            if name == linedate[0] and password == linedate[1]:
                print("用户名密码正确，登陆成功。")
                return True
        print("用户名密码不正确。")
        return False
def addlockuser(name,userfile,userlockfile):
    with open(userfile,'r',encoding='utf-8')as fd1,open(userlockfile,'a',encoding='utf-8')as fd2:
        line=fd1.readline()
        while line:
            linedate=line.split(":")
            line=fd1.readline()
            if name==linedate[0]:
                fd2.write(name+"\n")
                print(name+"被加入被锁用户列表")
                return ''
trynum=1
while trynum<=3:
    #获得用户输入的用户名和密码
    print("第"+str(trynum)+"次输入。")
    trynum +=1
    name=input("Username: ")
    password=input("Password: ")
    #判断输入的用户名是否在被锁用户列表中
    if checklock(name,"lockuser.txt"):
        exit()
    #判断是否和存储的用户名密码匹配
    elif checkmatch(name,password,"user.txt"):
        exit()
    elif trynum==4:
    #3次输入不对，加入被锁用户文件
        addlockuser(name,"user.txt","lockuser.txt")
        exit()

其中：lockuser.txt为空，当然你也可以自己设置；user.txt中文本为

编写完成啦！！！自己可以调试下代码啊~~~

转载于:https://my.oschina.net/pansy0425/blog/3026640