机器学习深度学习面试题——Python基础知识第2篇,续第1篇

机器学习深度学习面试题——Python基础知识第2篇,续第1篇,第1张

机器学习深度学习面试题——Python基础知识第2篇,续第1篇

提示:
第1篇如下:
(1)机器学习深度学习面试题——Python基础知识

第一篇有:
python 深拷贝与浅拷贝
python多线程能用多个cpu么?
python垃圾回收机制
python里的生成器是什么
迭代器和生成器的区别
装饰器
python有哪些数据类型
Python 中列表( List )中的 del,remove,和 pop 等的用法和区别
python yeild 和return的区别
python set底层实现
python字典和set()的区别
怎么对字典的值进行排序?
init和new和call的区别
import常用库
python的lamda函数
Python内存管理
python在内存上做了哪些优化?
Python中类方法和静态方法的区别
python多线程怎么实现
点积和矩阵相乘的区别?
Python中错误和异常处理
Python 的传参是传值还是传址?
什么是猴子补丁?
当退出 Python 时是否释放所有内存分配?
Python 中的 is 和 == 有什么区别?
gbk和utf8的区别
遍历字典可以用什么方法
反转列表的方法
python 元组中元组转为字典
range在python2和python3里的区别
init.py 文件的作用以及意义
python的字符串的加法和乘法操作
python 元组骚操作
python 集合set骚操作
python 字典dict骚操作
pyhton 字符串骚操作
python 字符串和数字转换
python格式化字符串
python操作字符串,拼接,删除,查找,替换等
python的函数定义调用
python函数的变量问题
python函数类型,函数嵌套
python过滤函数filter()
python的映射函数map()
python的lambda函数
————————————————
版权声明:本文为CSDN博主「冰露可乐」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/weixin_46838716/article/details/124575299

由于第一篇已经很长了,咱们继续新开第2篇,以免疲乏!

第二篇目录如下:
看本文的时候,从文末一节一节,往回看!
看本文的时候,从文末一节一节,往回看!
看本文的时候,从文末一节一节,往回看!

(1)面向对象的python类
(2)python对象的继承性
(3)python对象的多态性
(4)python的异常处理
(5)python的模块:数学计算模块,时间模块
(6)python的正则表达式模块
(7)python文件读写操作

推荐课程了解:字节跳动Python内部培训 不看原地巨亏2亿 手把手教学 学完即可就业!!!


文章目录
  • 机器学习深度学习面试题——Python基础知识第2篇,续第1篇
    • @[TOC](文章目录)
  • python文件读写操作
  • python的正则表达式模块
  • python的模块:数学计算模块
  • python的异常处理
  • python对象的多态性
  • python对象的继承性
  • 面向对象的python类
  • 总结
python文件读写操作






这些知识了解,用的时候,直接百度即可
在Windows的文件路径分隔符和Linux系统中不一样,最好写正斜杠
\转义一个
正斜杠就是一个/
统一正斜杠是最好的

file = 'D:/360Downloads/test.txt'
s = 'hhhhhh'

f = open(file, 'w+')
f.write(s)

python的正则表达式模块




查到就行,不用背

中间那个163是不对的

import re

p = '\w+@xyz\.com'  # 匹配规则,前面很多字符,中间xyz,后面.com
s1 = 'abc def aaa eee@xyz.com'
s2 = 'abc def aaa eee@163.com'
print(re.search(p, s1))
print(re.search(p, s2))

<re.Match object; span=(12, 23), match='eee@xyz.com'>
None
import re

p = 'JAVA|java|Java'  # 匹配规则,|或
s1 = 'Java JAVA java eee@xyz.com'
print(re.search(p, s1))
print(re.findall(p, s1))

<re.Match object; span=(0, 4), match='Java'>
['Java', 'JAVA', 'java']


0是没有限制,之后都是限制

import re

p = '\d+'  # 匹配规则,|或
s1 = 'AB12CD34EF'
print(re.sub(p, ' ', s1))  # 不限制个数替换
print(re.sub(p, ' ', s1, count=1))  # 限制1个替换
print(re.sub(p, ' ', s1, count=2))  # 限制1个替换

AB CD EF
AB CD34EF
AB CD EF


p = '\d+'  # 匹配规则,|或
s1 = 'AB12CD34EF'
print(re.split(p, s1))
print(re.split(p, s1, maxsplit=1))
print(re.split(p, s1, maxsplit=2))

['AB', 'CD', 'EF']
['AB', 'CD34EF']
['AB', 'CD', 'EF']
python的模块:数学计算模块



和java中的有序表里面的ceiling(x)一样>=x
floor(x),<=x
三角函数有一批很多



timezoneinfo

d = datetime.datetime(2022,2,30)
print(d)

    d = datetime.datetime(2022,2,30)
ValueError: day is out of range for month


d = datetime.datetime(2022,2,1)
print(d)

2022-02-01 00:00:00


时间戳:原来如此!

print(datetime.datetime.today())
print(datetime.datetime.now())
print(datetime.datetime.fromtimestamp(1000000000))

2022-05-12 11:22:08.687270
2022-05-12 11:22:08.687269
2001-09-09 09:46:40

print(datetime.date(2022,2,1))
print(datetime.date(2022,2,29))

2022-02-01
ValueError: day is out of range for month

print(datetime.date.today())
print(datetime.date.fromtimestamp(1000000000))
2022-05-12
2001-09-09

print(datetime.time(12,0,0))
12:00:00


间隔x之后,应该是啥时间

d = datetime.datetime.today()
print(d + datetime.timedelta(days=100))
print(d + datetime.timedelta(weeks=10))

2022-08-20 11:30:07.628931
2022-07-21 11:30:07.628931



d= datetime.datetime.today()  # 对象
print(datetime.datetime.strftime(d,"%Y-%m-%d %H:%M:%S"))
str = '2022-05-12 11:36:52'
print(datetime.datetime.strptime(str, '%Y-%m-%d %H:%M:%S'))

2022-05-12 11:37:34
2022-05-12 11:36:52
python的异常处理



使得程序更加健壮

print(1 / 0)

ZeroDivisionError: division by zero

了解常规错误,除零异常,不会可以百度,但是知道的话,速度可以快点解决。

try:
    print(1 / 0)
except ZeroDivisionError as e:  # 赋值给e
    print("不能除0")

不能除0


分门别类处理

ff = input()
try:
    print(ff / 0)
except ZeroDivisionError as e:  # 赋值给e
    print("不能除0 {}".format(e))
except ValueError as e:
    print("输入了无效数字{}".format(e))
    
TypeError: unsupported operand type(s) for /: 'str' and 'int'

ff = input()
try:
    print(ff / 0)
except (ZeroDivisionError,ValueError) as e:  # 赋值给e
    print("不能除0 {}".format(e))
    print("输入了无效数字{}".format(e))

TypeError: unsupported operand type(s) for /: 'str' and 'int'

ff = input()
try:
    ff = int(ff)
    try: # 上面那个有问题,不要进来了,没问题 再进来
        print(1 / ff)
    except ZeroDivisionError as e:
        print("不能除0 {}".format(e))
except ValueError as e:  # 先看字符有效吗
    print("输入了无效数字{}".format(e))

ff
输入了无效数字invalid literal for int() with base 10: 'ff'

0
不能除0 division by zero


为了解决空间资源浪费问题

ff = input()
try:
    ff = int(ff)
    try: # 上面那个有问题,不要进来了,没问题 再进来
        print(1 / ff)
    except ZeroDivisionError as e:
        print("不能除0 {}".format(e))
except ValueError as e:  # 先看字符有效吗
    print("输入了无效数字{}".format(e))
finally:
    print("释放了")

0
不能除0 division by zero
释放了

上面都是系统的
但是公司有自己的需求的话,自定义


raise语句引发异常
目的自定义的类,需要我们自己引发


class MyERROR(Exception):  # 继承父类
    def __init__(self, message):
        super().__init__(message) # 调用父类的构造

ff = input()
try:
    ff = int(ff)
    try: # 上面那个有问题,不要进来了,没问题 再进来
        print(1 / ff)
    except ZeroDivisionError as e:
        print("不能除0 {}".format(e))
        raise MyERROR("你骚得很哪,整个0干啥呢")
except ValueError as e:  # 先看字符有效吗
    print("输入了无效数字{}".format(e))
    raise MyERROR("你很奇怪,整个不是整形的数字干啥呢")
finally:
    print("释放了")
    

0
不能除0 division by zero
Traceback (most recent call last):
释放了
 
ZeroDivisionError: division by zero
During handling of the above exception, another exception occurred:
    raise MyERROR("你骚得很哪,整个0干啥呢")
__main__.MyERROR: 你骚得很哪,整个0干啥呢
python对象的多态性


不同的行为和方式
多种形态

多态一定是在继承情况下,不同实例对象之间的区别

class Animal:
    isAnimal = True  # 类变量,整个类共有的东西
    def __init__(self, name):  # 构造函数,和java类似,初始化函数
        # self自动传入,不用传递
        self.name = name
    def speak(self):
        print("动物具体怎么叫呢?不知道呢……")  # 父类方法

class Cat(Animal):
    def __init__(self, name):  # 构造函数,和java类似,初始化函数
        # self自动传入,不用传递
        super().__init__(name) #直接父类构造

    def speak(self):
        print("猫咪:喵喵叫,这种形态")  # 父类方法


class Dog(Animal):
    def __init__(self, name):  # 构造函数,和java类似,初始化函数
        # self自动传入,不用传递
        super().__init__(name)  # 直接父类构造

    def speak(self):
        print("狗子:汪汪叫,这种形态")  # 父类方法


cat = Cat("ba")
dog = Dog("ha")
cat.speak()
dog.speak()

猫咪:喵喵叫,这种形态
狗子:汪汪叫,这种形态


不同的类之间的多态

class Animal:
    def speak(self):
        print("动物具体怎么叫呢?不知道呢……")  # 父类方法

class Cat(Animal):
    def speak(self):
        print("猫咪:喵喵叫,这种形态")  # 父类方法

class Dog(Animal):
    def speak(self):
        print("狗子:汪汪叫,这种形态")  # 父类方法

class Car():
    def speak(self):
        print("车子:滴滴叫,这种形态")  # 父类方法

class Car2():
    def speak2(self):
        print("车子:滴滴叫,这种形态")  # 父类方法

def start(obj):
    obj.speak()  # 接受一个obj对象,可以获取他们所有的方法

start(Cat())  # 传递对象
start(Dog())
start(Car())
start(Car2())

不管是动物不是动物,只要有speak函数就能用
没有speak是不能调用的

猫咪:喵喵叫,这种形态
狗子:汪汪叫,这种形态
车子:滴滴叫,这种形态
AttributeError: 'Car2' object has no attribute 'speak'
python对象的继承性



子承父业
变量,方法,统统继承

class Animal:
    isAnimal = True  # 类变量,整个类共有的东西
    def __init__(self, name):  # 构造函数,和java类似,初始化函数
        # self自动传入,不用传递
        self.name = name

    def show_info(self):
        return "动物名字:{}".format(self.name)

    def move(self):
        print("动一下……")  # 父类方法

class Cat(Animal):
    def __init__(self, name, age):
        super().__init__(name)  #调用父类的构造方法,把变量初始化
        self.age = age


cat = Cat("xxx", 1)
print(cat.show_info())
cat.move()  # 父类的所有方法都可以调用

动物名字:xxx
动一下……


很多java啥的不支持多继承
因为马和驴都有run函数,到底骡子继承谁呢???糊了
但是python就可以哦!!!
如果子类,先放马,再放驴,那就先继承马的,再继承驴的
所以run看马的

class Animal:
    isAnimal = True  # 类变量,整个类共有的东西
    def __init__(self, name):  # 构造函数,和java类似,初始化函数
        # self自动传入,不用传递
        self.name = name

    def show_info(self):
        return "动物名字:{}".format(self.name)

    def move(self):
        print("动物动一下……")  # 父类方法

class People:
    isPeople = True  # 类变量,整个类共有的东西
    def __init__(self, name):  # 构造函数,和java类似,初始化函数
        # self自动传入,不用传递
        self.name = name

    def peopleGo(self):
        print("人走一波")

    def move(self):
        print("人来动一下……")  # 父类方法

class Cat(Animal, People): # 先继承动物
    def __init__(self, name, age):
        super().__init__(name)  #调用父类的构造方法,把变量初始化
        self.age = age

cat = Cat("xxx", 1)
print(cat.show_info())
cat.move()  # 父类的所有方法都可以调用
cat.peopleGo()  # 父类的所有方法都可以调用

动物名字:xxx
动物动一下……
人走一波

虽然都是move,但是先继承动物,那就让动物动一下

class Animal:
    isAnimal = True  # 类变量,整个类共有的东西
    def __init__(self, name):  # 构造函数,和java类似,初始化函数
        # self自动传入,不用传递
        self.name = name

    def show_info(self):
        return "动物名字:{}".format(self.name)

    def move(self):
        print("动物动一下……")  # 父类方法

class People:
    isPeople = True  # 类变量,整个类共有的东西
    def __init__(self, name):  # 构造函数,和java类似,初始化函数
        # self自动传入,不用传递
        self.name = name

    def peopleGo(self):
        print("人走一波")

    def move(self):
        print("人来动一下……")  # 父类方法

class Cat(Animal, People): # 先继承动物
    def __init__(self, name, age):
        super().__init__(name)  #调用父类的构造方法,把变量初始化
        self.age = age

    def show_info(self):
        print("骡子名字是{}".format(self.name))

cat = Cat("sao", 1)
print(cat.show_info())

骡子名字是sao

屏蔽改造,方法的重写,java中叫:Override

面向对象的python类


将真实世界的对象,定义到咱们的数据结构中
内部有很多属性,定义函数啥的

(object)所有类的根类,老祖宗

# coding = utf-8

class Car:
    # 类体
    pass  #保持代码的完整性


和java类似

class Car:
    # 类体
    pass  #保持代码的完整性

# 比较java简单点
car = Car()  # 类是对象的模板,在模板上把具体实例的属性赋值不同
# 这样的话,就很多具体的对象就来了
print(type(car))
<class '__main__.Car'>


class Dog:
    def __init__(self, name, age):  # 初始化函数
        self.name = name
        self.age = age

dog = Dog("hh", 1)
print('{} {}'.format(dog.name, dog.age))
hh 1

class Dog:
    def __init__(self, name, age, sex='女性'):  # 构造函数,和java类似,初始化函数
        # self自动传入,不用传递
        self.name = name
        self.age = age
        self.sex = sex

dog = Dog("hh", 1)
dog2 = Dog("hh", 1, "男性")
print('{} {} {}'.format(dog.name, dog.age, dog.sex))
print('{} {} {}'.format(dog2.name, dog2.age, dog2.sex))

hh 1 女性
hh 1 男性


构造方法之外的变量,叫类变量!

class Dog:
    isDog = True  # 类变量,整个类共有的东西
    def __init__(self, name, age, sex='女性'):  # 构造函数,和java类似,初始化函数
        # self自动传入,不用传递
        self.name = name
        self.age = age
        self.sex = sex

dog = Dog("hh", 1)
dog2 = Dog("hh", 1, "男性")
print('{} {} {}'.format(dog.name, dog.age, dog.sex))
print('{} {} {}'.format(dog2.name, dog2.age, dog2.sex))
print(Dog.isDog)
print(dog.isDog)  # 两种都行

hh 1 女性
hh 1 男性
True
True


@X,X是装饰器,classmethod系统的装饰器

class Dog:
    isDog = True  # 类变量,整个类共有的东西
    def __init__(self, name, age, sex='女性'):  # 构造函数,和java类似,初始化函数
        # self自动传入,不用传递
        self.name = name
        self.age = age
        self.sex = sex

    @classmethod
    def fclass(cls, t):
        return cls.isDog + t

dog = Dog("hh", 1)
y = Dog.fclass(1)

2


这些知识,在java中类似,c++中类似
思想就一样的

java中private,而这里是__,内部可以访问,外部不行

class Dog:
    isDog = True  # 类变量,整个类共有的东西
    def __init__(self, name, age, sex='女性'):  # 构造函数,和java类似,初始化函数
        # self自动传入,不用传递
        self.name = name
        self.age = age
        self.sex = sex
        self.__wife = 10000

    def F2(self, x):
        return self.__wife + x  # 内部是可以随意访问的,外部不行
        
dog = Dog("hh", 1)
y = dog.F2(10)
print(y)
y2 = dog.__wife  # 压根没有

10010
AttributeError: 'Dog' object has no attribute '__wife'


与私有变量类似,java中private,这里是__

class Dog:
    isDog = True  # 类变量,整个类共有的东西
    def __init__(self, name, age, sex='女性'):  # 构造函数,和java类似,初始化函数
        # self自动传入,不用传递
        self.name = name
        self.age = age
        self.sex = sex
        self.__wife = 10000
    def __F3(self,x):
        return 100

    def F2(self, x):
        return self.__wife + x + self.__F3(x) # 内部是可以随意访问的,外部不行

dog = Dog("hh", 1)
y = dog.F2(10)
print(y)
print(Dog.__F3(1))

10110
AttributeError: type object 'Dog' has no attribute '__F3'



用属性替代get方法
@property
去掉私有变量的下划线做函数age
说明这个是一个属性

@age.setter
然后赋值,设置私有变量


访问私有变量的方式

class Dog:
    isDog = True  # 类变量,整个类共有的东西
    def __init__(self, name, age, sex='女性'):  # 构造函数,和java类似,初始化函数
        # self自动传入,不用传递
        self.name = name
        self.age = age
        self.sex = sex
        self.__wife = 10000

    @property
    def wife(self):
        return self.__wife  # 取值
    # 装饰器的格式,要搞清楚
    @wife.setter
    def wife(self, s):
        self.__wife = s  # 赋值
dog = Dog("hh", 1)
print(dog.wife)
dog.wife = 20000
print(dog.wife)

10000
20000

总结

提示:重要经验:

1)没事来复习看看,这些python的知识,进大厂之后,如果是研究算法啥的,就需要用python跑深度学习,如果是开发,那就是需要java或者c++,因此python一般来说是必会的知识
2)python基础知识,经常在互联网大厂的笔试题中出现选择题,让你计算代码的结果,问你内部python的区别啥的,还有补充代码,反正需要学习和了解。
3)笔试求AC,可以不考虑空间复杂度,但是面试既要考虑时间复杂度最优,也要考虑空间复杂度最优。

欢迎分享,转载请注明来源:内存溢出

原文地址:http://outofmemory.cn/langs/918465.html

(0)
打赏 微信扫一扫微信扫一扫 支付宝扫一扫支付宝扫一扫
上一篇 2022-05-16
下一篇2022-05-16

随机推荐

发表评论

登录后才能评论

评论列表(0条)

    保存