面试题总结

 -          rwx                  rwx               rwx
类型        用户权限               用户所在组权限   其他用户权限

__init__实际上不能算得上的构造函数，__new__才能创建实例的方法。
__init__是当实例对象创建完成后被调用的，然后设置对象属性的一些初始值。
__new__是在实例创建之前被调用的，因为他的任务就是创建实例然后返回该实例，是个静态方法。
也就是__new__是在__init__之前被调用的，__new__的返回值（实例）将传递给__init__方法的第一个参数，然后__init__给这个实例设置一些参数

Python是一门解释性语言，直到发现了*.pyc文件的存在。如果是解释型语言，那么生成的pyc文件又是什么？

编译型语言在程序执行之前，先会通过编译器对程序执行一个编译的过程，把程序转变成机器语言。运行时就不需要翻译，而直接执行就可以了。最典型的例子就是C语言。

解释型语言就没有这个编译的过程，而是在程序运行的时候，通过解释器对程序逐行作出解释，然后直接运行，最典型的例子是Ruby。

但是我们也不能一概而论，一些解释型语言也可以通过解释器的优化来在对程序做出翻译时对整个程序做出优化，从而在效率上超过编译型语言。

在程序运行期间，编译结果存在于内存的PyCodeObject对象中，当Python结束运行后，编译结果会被保存到pyc文件中，
在下一次运行相同程序时，Python会根据pyc文件中记录的编译结果直接在内存中重新建立PyCodeObject对象，而不用再次对源文件进行编译。

PyCodeObject结构体在C源代码中有相应的声明，Python的import机制会触发pyc文件的生成，
实际这不是生成pyc文件的唯一姿势。我们可以通过compile内建函数来查看这个PyCodeObject对象的一些信息

pyc文件是导包或者是引用的时候产生的，举个例子我有一个b.py文件，我从a.py中引用b.py文件，执行a.py文件时，就会产生b.py文件的pyc文件，
这个pyc文件是字节码文件。当再次运行a.py时，如果a.py没有发生变化，则运行pyc文件，当a.py发生变化时，就会重新生成pyc文件，然后在执行pyc文件。
pyc文件是再次转化成机器码才执行的。
    

还有那个正在运行的py文件，在未运行的代码处修改时不会执行的，也就是运行原代码，原因是代码是加载到内存中执行的，你手动修改时只是在硬盘中的。

可以被迭代要满足的要求就叫做可迭代协议。可迭代协议的定义非常简单，就是内部实现了__iter__方法。

可以被for循环的都是可迭代的，要想可迭代，内部必须有一个__iter__方法。

迭代器遵循迭代器协议：必须拥有__iter__方法和__next__方法。

我们知道的迭代器有两种：一种是调用方法直接返回的，一种是可迭代对象通过执行iter方法得到的，迭代器有的好处是可以节省内存。

如果在某些情况下，我们也需要节省内存,就只能自己写。我们自己写的这个能实现迭代器功能的东西就叫生成器。

yield可以为我们从函数中返回值，但是yield又不同于return，return的执行意味着程序的结束，
调用生成器函数不会得到返回的具体的值，而是得到一个可迭代的对象。每一次获取这个可迭代对象的值，就能推动函数的执行，获取新的返回值。直到函数执行结束。

import time
def func1():
    a=1
    print("a变量")
    yield a
    b=2
    print("b变量")
    yield b

g1=func1()
print(g1)
print(next(g1))  # next一次，取出来一次值
print(next(g1))  # 再next一次，再取值

def func():
    print(123)
    content = yield 1
    print("——",content)
    print(333)
    yield 2
g = func()
# ret = g.__next__()
# print("****",ret)
print(next(g))
ret = g.send("hh")    #send的效果和next一样
print(ret)


#send 获取下一个值的效果和next基本一致
#只是在获取下一个值的时候，给上一yield的位置传递一个数据
#使用send的注意事项
    # 第一次使用生成器的时候 是用next获取下一个值
    # 最后一个yield不能接受外部的值

#列表解析
sum([i for i in range(100000000)])#内存占用大,机器容易卡死
 
#生成器表达式
sum(i for i in range(100000000))#几乎不占内存

1.延迟计算，一次返回一个结果。也就是说，它不会一次生成所有的结果，这对于大数据量处理，将会非常有用。

2.提高代码可读性

@classmethod和@staticmethod都可以不实例化类而直接使用类名.类方法名()的方式进行调用，二者都是修饰方式。
区别就是当基类被删除时，再次使用@staticmethod方式进行调用时，会报错；但是@classmethod不会受到影响。可以继续使用。
@classmethod和@staticmethod都不需要再传入self，但是@classmethod装饰的函数第一位必须传入一个参数，
多用cls，这个cls则代表当前的类。其他参数则看自己的使用情况进行传参。

class A(object):
    a = "哈哈哈"
    def b(self):
        return self.a
    @staticmethod
    def c():
        return A.a
    @classmethod
    def d(cls):
        return cls.a

class B(A):
    pass
print(A.a)
print(A.b())   # 报错 必须实例化类才可以
print(A.c())
print(A.d())
del A
# print(B.a)
print(B.b()) # 报错 必须实例化类
print(B.c())    #报错  A not defined
print(B.d())    

# 方法一：递归切片

def is_huiwen(s):
    if len(s) < 2:
        return True
    if s[0] == s[-1]:
        return is_huiwen(s[1:-1])
    else:
        return False


print(is_huiwen("abcdcba"))

# 方法二：将首尾依次对比
s = input("请输入一个字符串：")
if not s:
    print("请不要输入空字符串：")
    s = input("请重新输入一个字符串：")
a = len(s)
i = 0
count = 1
while i <= (a/2):
    if s[i] == s[a-i-1]:
        count = 1
        i +=1
    else:
        count = 0
        break
if count == 1:
    print("您输入的字符串是回文")
else:
    print("您输入的字符串不是回文")

# 方法三:reversed()方法
s = input("请输入一个字符串：")
if not s:
    print("请不要输入空字符串")
    s = input("请重新输入一个字符串")
s1 = reversed(list(s))
if list(s1) == list(s):
    print("您输入的是一个回文字符串")
else:
    print("您输入的不是一个回文字符串")

def is_huiwen(s):
    # 判断当前字符串是否是回文字符串
    for i in range(len(s)):
        if s[i] != s[len(s)-i-1]:
            return False
    return True


def find_huiwen(s):
    huiwenchuan = []
    for i in range(len(s)):
        for j in range(i+1,len(s)):
            s1 = s[i:j+1]
            if is_huiwen(s1):
                huiwenchuan.append(s1)
    return huiwenchuan


if __name__ == ‘__main__‘:
    s = "aabcbaadedffcde"
    huiwen = find_huiwen(s)
    print(huiwen)

import os


def search_file(path, str):  # 传入当前的绝对路径以及指定字符串
    # 首先先找到当前目录下的所有文件
    for file in os.listdir(path):  # os.listdir(path)是当前这个path路径下的所有文件的列表
        this_path = os.path.join(path, file)
        if os.path.isfile(this_path):  # 判断这个路径对应的是目录还是文件，是文件就走下去
            if str in file:
                print(this_path)
        else:  # 不是就再继续再次执行这个函数，递归下去
            search_file(this_path, str)  # 递归
    else:
        return None


search_file(os.path.abspath("."), "t")  # 返回path规范化的绝对路径

os.makedirs(‘dirname1/dirname2‘)    可生成多层递归目录
os.removedirs(‘dirname1‘)    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir(‘dirname‘)    生成单级目录；相当于shell中mkdir dirname
os.rmdir(‘dirname‘)    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir(‘dirname‘)    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat(‘path/filename‘)  获取文件/目录信息

os.system("bash command")  运行shell命令，直接显示
os.popen("bash command).read()  运行shell命令，获取执行结果
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd

os.path
os.path.abspath(path) 返回path规范化的绝对路径
os.path.split(path) 将path分割成目录和文件名二元组返回 
os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素 
os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果path是绝对路径，返回True
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小

# 1、l = [2, 3, 4, 7, 9] 用切片实现取出偶数位+1的值求和
l = [2, 3, 4, 7, 9]
l1 = l[::2]
sum = 0
for i in l1:
    i1 = i + 1
    sum += i1
print(sum)

table:
user|dep|salary
uuu | A |22222
jjj | B |3333
kkk | C |33333
kas | A |3456

 select * from t1 order by salary desc limit 3;