一、Python所有方向的学习路线
Python所有方向的技术点做的整理,形成各个领域的知识点汇总,它的用处就在于,你可以按照下面的知识点去找对应的学习资源,保证自己学得较为全面。
二、Python必备开发工具
工具都帮大家整理好了,安装就可直接上手!
三、最新Python学习笔记
当我学到一定基础,有自己的理解能力的时候,会去阅读一些前辈整理的书籍或者手写的笔记资料,这些笔记详细记载了他们对一些技术点的理解,这些理解是比较独到,可以学到不一样的思路。
四、Python视频合集
观看全面零基础学习视频,看视频学习是最快捷也是最有效果的方式,跟着视频中老师的思路,从基础到深入,还是很容易入门的。
五、实战案例
纸上得来终觉浅,要学会跟着视频一起敲,要动手实操,才能将自己的所学运用到实际当中去,这时候可以搞点实战案例来学习。
六、面试宝典
简历模板![在这里插入图片描述](https://img-blog.csdnimg.cn/646863996ac44da8af500c049bb72fbd.png#pic_center)
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
super()表示的是 子类的mro()列表中的下一个
print(G.mro())
[<class ‘__main__.G’>, <class ‘__main__.D’>, <class ‘__main__.A’>, <class ‘__main__.B’>, <class ‘object’>]
print(F.mro())
<class ‘__main__.F’>, <class ‘__main__.C’>, <class ‘__main__.B’>, <class ‘__main__.D’>, <class ‘__main__.A’>, <class ‘object’>表示的是 子类的mro()列表中的下一个
print(G.mro())
[<class ‘__main__.G’>, <class ‘__main__.D’>, <class ‘__main__.A’>, <class ‘__main__.B’>, <class ‘object’>]
print(F.mro())
[<class ‘__main__.F’>, <class ‘__main__.C’>, <class ‘__main__.B’>, <class ‘__main__.D’>, <class ‘__main__.A’>, <class ‘object’>]
class A(object):
def __init__(self):
print(‘A’)
super(A, self).init()
class B(object):
def __init__(self):
print(‘B’)
super(B, self).init()
class C(A):
def __init__(self):
print(‘C’)
super(C, self).init()
class D(A):
def __init__(self):
print(‘D’)
super(D, self).init()
class E(B, C):
def __init__(self):
print(‘E’)
super(E, self).init()
class F(C, B, D):
def __init__(self):
print(‘F’)
super(F, self).init()
class G(D, B):
def __init__(self):
print(‘G’)
super(G, self).init()
if name == ‘__main__’:
g = G()
f = F()
G
D
A
B
F
C
B
D
A A(object):
def __init__(self):
print(‘A’)
super(A, self).init()
class B(object):
def __init__(self):
print(‘B’)
super(B, self).init()
class C(A):
def __init__(self):
print(‘C’)
super(C, self).init()
class D(A):
def __init__(self):
print(‘D’)
super(D, self).init()
class E(B, C):
def __init__(self):
print(‘E’)
super(E, self).init()
class F(C, B, D):
def __init__(self):
print(‘F’)
super(F, self).init()
class G(D, B):
def __init__(self):
print(‘G’)
super(G, self).init()
if name == ‘__main__’:
g = G()
f = F()
G
D
A
B
F
C
B
D
A
15,请编写一段符合多态特性的代码.
class Animal:
def __init__(self, name):
self.name = name
class People(Animal):
def talk(self):
print(‘%s is talking’ % self.name)
class Dog(Animal):
def talk(self):
print(‘%s is talking’ % self.name)
def func(animal):
animal.talk()
p=People(‘alice’)
d=Dog(‘wang’)
func§
func(d)
‘’’
alice is talking
wang is talking
‘’’ Animal:
def __init__(self, name):
self.name = name
class People(Animal):
def talk(self):
print(‘%s is talking’ % self.name)
class Dog(Animal):
def talk(self):
print(‘%s is talking’ % self.name)
def func(animal):
animal.talk()
p=People(‘alice’)
d=Dog(‘wang’)
func§
func(d)
‘’’
alice is talking
wang is talking
‘’’
16,很多同学都是学会了面向对象的语法,却依然写不出面向对象的程序,原因是什么呢?原因就是因为你还没掌握一门面向对象设计利器,即领域建模,请解释下什么是领域建模,以及如何通过其设计面向对象的程序? <http://www.cnblogs.com/alex3714/articles/5188179.html> 此blog最后面有详解
领域模型,顾名思义,就是需求所涉及的领域的一个建模,更通俗的讲法是业务模型。
定义:
需求到面向对象的桥梁
作用:
1.发掘重要的业务领域概念
2.建立业务领域概念之间的关系
方法:
从用例中找名词
领域建模的三字经方法:找名词、加属性、连关系。
参考:http://www.cnblogs.com/linhaifeng/articles/6182264.html#_label15
http://www.cnblogs.com/linhaifeng/articles/7341318.html1.发掘重要的业务领域概念
2.建立业务领域概念之间的关系
方法:
从用例中找名词
领域建模的三字经方法:找名词、加属性、连关系。
参考:http://www.cnblogs.com/linhaifeng/articles/6182264.html#_label15
http://www.cnblogs.com/linhaifeng/articles/7341318.html
17,请写一个小游戏,人狗大站,2个角色,人和狗,游戏开始后,生成2个人,3条狗,互相混战,人被狗咬了会掉血,狗被人打了也掉血,狗和人的攻击力,具备的功能都不一样。注意,请按题14领域建模的方式来设计类。
class Animal:
def __init__(self, name,life_value,aggressivity):
self.name = name
self.life_value = life_value
self.aggressivity = aggressivity
**def** **attack**(self,enemy):
enemy.life_value -= self.aggressivity
class People(Animal):
camp=‘home’
def attack(self,enemy):
super().attack(enemy)
print(‘from people’)
class Dog(Animal):
camp=‘wo’
def attack(self,enemy):
super().attack(enemy)
print(‘from dog’)
p1=People(‘alice’,80,30)
p1=People(‘alex’,80,30)
d1=Dog(‘w1’,90,50)
d2=Dog(‘w2’,90,50)
d3=Dog(‘w3’,90,50)
print(p1.life_value)
d1.attack(p1)
print(p1.life_value)
print(d1.life_value)
p1.attack(d1)
print(d1.life_value) Animal:
**def** **\_\_init\_\_**(self, name,life_value,aggressivity):
self.name = name
self.life_value = life_value
self.aggressivity = aggressivity
**def** **attack**(self,enemy):
enemy.life_value -= self.aggressivity
class People(Animal):
camp=‘home’
def attack(self,enemy):
super().attack(enemy)
print(‘from people’)
class Dog(Animal):
camp=‘wo’
def attack(self,enemy):
super().attack(enemy)
print(‘from dog’)
p1=People(‘alice’,80,30)
p1=People(‘alex’,80,30)
d1=Dog(‘w1’,90,50)
d2=Dog(‘w2’,90,50)
d3=Dog(‘w3’,90,50)
print(p1.life_value)
d1.attack(p1)
print(p1.life_value)
print(d1.life_value)
p1.attack(d1)
print(d1.life_value)
18,编写程序, 在元类中控制把自定义类的数据属性都变成大写.
19,编写程序, 在元类中控制自定义的类无需init方法.
class Mymeta(type):
def __new__(cls,class_name,class_bases,class_dic):
update_dic = {}
for i in class_dic:
if not callable(class_dic[i]) and not i.startswith(‘__’):
update_dic[i.upper()]=class_dic[i]
else:
update_dic[i]=class_dic[i]
return type.new(cls,class_name,class_bases,update_dic)
**def** **\_\_call\_\_**(self, *args, **kwargs):
obj=object.__new__(self)
**if** args:
**raise** TypeError('must be keyword argument')
**for** i **in** kwargs:
obj.__dict__[i]=kwargs[i]
**return** obj
class Chinese(metaclass=Mymeta):
country=‘china’
tag=‘legend of the dragon’
**def** **talk**(self):
print('%s is talking'%self.name)
print(Chinese.__dict__)
ch=Chinese(name=‘alice’,age=18)
ch.talk()
print(ch.__dict__) Mymeta(type):
**def** **\_\_new\_\_**(cls,class_name,class_bases,class_dic):
update_dic = {}
**for** i **in** class_dic:
**if** **not** callable(class_dic[i]) **and** **not** i.startswith('\_\_'):
update_dic[i.upper()]=class_dic[i]
**else**:
update_dic[i]=class_dic[i]
**return** type.__new__(cls,class_name,class_bases,update_dic)
**def** **\_\_call\_\_**(self, *args, **kwargs):
obj=object.__new__(self)
**if** args:
**raise** TypeError('must be keyword argument')
**for** i **in** kwargs:
obj.__dict__[i]=kwargs[i]
**return** obj
class Chinese(metaclass=Mymeta):
country=‘china’
tag=‘legend of the dragon’
**def** **talk**(self):
print('%s is talking'%self.name)
print(Chinese.__dict__)
ch=Chinese(name=‘alice’,age=18)
ch.talk()
print(ch.__dict__)
20,编写程序, 编写一个学生类, 要求有一个计数器的属性, 统计总共实例化了多少个学生.
class Student:
__count = 0
def __init__(self, name, age):
self.name = name
self.age = age
Student.__count += 1
@property
def talk(self):
print(‘%s is talking’ % self.name)
@staticmethod
def tell_count():
print(‘总共实例化了 %s 人’ % Student.__count)
s1 = Student(‘alice’, 18)
s2 = Student(‘alex’, 20)
s3 = Student(‘egon’, 28)
Student.tell_count()
s1.tell_count()
s1.talk
s2.talk Student:
__count = 0
**def** **\_\_init\_\_**(self, name, age):
self.name = name
self.age = age
Student.__count += 1
@property
def talk(self):
print(‘%s is talking’ % self.name)
@staticmethod
def tell_count():
print(‘总共实例化了 %s 人’ % Student.__count)
s1 = Student(‘alice’, 18)
s2 = Student(‘alex’, 20)
s3 = Student(‘egon’, 28)
Student.tell_count()
s1.tell_count()
s1.talk
s2.talk
结果:
结果:
1
{‘name’: ‘james’, ‘sex’: ‘male’, ‘age’: 32}
2
{‘name’: ‘enbede’, ‘sex’: ‘male’, ‘age’: 23}
2
{‘__module__’: ‘__main__’, ‘_count’: 2, ‘__init__’: <function Student.init at 0x00000190B1B959D8>, ‘learn’: <property object at 0x00000190B19047C8>, ‘tell_count’: <staticmethod object at 0x00000190B1B9CAC8>, ‘__dict__’: <attribute ‘__dict__’ of ‘Student’ objects>, ‘__weakref__’: <attribute ‘__weakref__’ of ‘Student’ objects>, ‘__doc__’: None}
总共实例化了:2
james is learning1
{‘name’: ‘james’, ‘sex’: ‘male’, ‘age’: 32}
2
{‘name’: ‘enbede’, ‘sex’: ‘male’, ‘age’: 23}
2
{‘__module__’: ‘__main__’, ‘_count’: 2, ‘__init__’: <function Student.init at 0x00000190B1B959D8>, ‘learn’: <property object at 0x00000190B19047C8>, ‘tell_count’: <staticmethod object at 0x00000190B1B9CAC8>, ‘__dict__’: <attribute ‘__dict__’ of ‘Student’ objects>, ‘__weakref__’: <attribute ‘__weakref__’ of ‘Student’ objects>, ‘__doc__’: None}
总共实例化了:2
james is learning
_*_ coding: utf-8 _*_
‘’’
练习1:编写一个学生类,产生一堆学生对象, (5分钟)
要求:
有一个计数器(属性),统计总共实例了多少个对象
‘’’
class Student:
count = 0
def __init__(self,name,sex,age):
self.name = name
self.sex = sex
self.age = age
Student.count +=1
**def** **learn**(self):
print("%s is learning"%self.name)
stu1 = Student(‘james’,‘male’,32)
print(stu1.count)
print(stu1.dict)
stu2 = Student(‘enbede’,‘male’,23)
print(stu2.count)
print(stu2.dict)
print(Student.count)
print(Student.dict)
结果:
1
{‘name’: ‘james’, ‘sex’: ‘male’, ‘age’: 32}
2
{‘name’: ‘enbede’, ‘sex’: ‘male’, ‘age’: 23}
2
{‘__module__’: ‘__main__’, ‘count’: 2, ‘__init__’: <function Student.__init__ at 0x000001E5DA9759D8>, ‘learn’: <function Student.learn at 0x000001E5DA975A60>, ‘__dict__’: <attribute ‘__dict__’ of ‘Student’ objects>, ‘__weakref__’: <attribute ‘__weakref__’ of ‘Student’ objects>, ‘__doc__’: None}
Process finished with exit code 0
‘’’
练习1:编写一个学生类,产生一堆学生对象, (5分钟)
要求:
有一个计数器(属性),统计总共实例了多少个对象
‘’’
class Student:
count = 0
def __init__(self,name,sex,age):
self.name = name
self.sex = sex
self.age = age
Student.count +=1
**def** **learn**(self):
print("%s is learning"%self.name)
stu1 = Student(‘james’,‘male’,32)
print(stu1.count)
print(stu1.dict)
stu2 = Student(‘enbede’,‘male’,23)
print(stu2.count)
print(stu2.dict)
print(Student.count)
print(Student.dict)
结果:
1
{‘name’: ‘james’, ‘sex’: ‘male’, ‘age’: 32}
2
{‘name’: ‘enbede’, ‘sex’: ‘male’, ‘age’: 23}
2
{‘__module__’: ‘__main__’, ‘count’: 2, ‘__init__’: <function Student.__init__ at 0x000001E5DA9759D8>, ‘learn’: <function Student.learn at 0x000001E5DA975A60>, ‘__dict__’: <attribute ‘__dict__’ of ‘Student’ objects>, ‘__weakref__’: <attribute ‘__weakref__’ of ‘Student’ objects>, ‘__doc__’: None}
Process finished with exit code 0
21,编写程序, A 继承了 B, 俩个类都实现了 handle 方法, 在 A 中的 handle 方法中调用 B 的 handle 方法
class B:
def handle(self):
print(‘from B handle’)
class A(B):
def handle(self):
super().handle()
# print(‘from A handle’)
a=A()
a.handle() B:
**def** **handle**(self):
print('from B handle')
class A(B):
def handle(self):
super().handle()
# print(‘from A handle’)
a=A()
a.handle()
22,编写程序, 如下有三点要求:
1. 自定义用户信息数据结构, 写入文件, 然后读取出内容, 利用json模块进行数据的序列化和反序列化
2. 定义用户类,定义方法db,例如 执行obj.db可以拿到用户数据结构
3. 在该类中实现登录、退出方法, 登录成功将状态(status)修改为True, 退出将状态修改为False(退出要判断是否处于登录状态).密码输入错误三次将设置锁定时间(下次登录如果和当前时间比较大于10秒即不允许登录)
import json
import time
class User:
def __init__(self, name, password):
self.name = name
self.password = password
self.status = False
self.timeout = 0
@property
def db(self):
with open(self.name+‘.txt’, ‘r’, encoding=‘utf-8’) as f:
data = json.load(f)
return data
**def** **save**(self):
obj={}
obj[self.name]={'password':self.password,'status':self.status,'timeout':self.timeout}
**with** open(self.name+'.txt', 'w', encoding='utf-8') **as** f:
json.dump(obj,f)
**def** **login**(self):
**with** open(self.name+'.txt', 'r+', encoding='utf-8') **as** f:
data = json.load(f)
count = 0
**while** count < 3:
password = input('password>>:').strip()
**if** password != data[self.name]['password']:
count += 1
**continue**
**else**:
**if** data[self.name]['timeout'] != 0:
**if** time.time() - data[self.name]['timeout'] > 10:
print('不允许登录了!超时')
**break**
**else**:
data[self.name]['status'] = **True**
f.seek(0)
f.truncate()
json.dump(data, f)
print('----welcome----')
**break**
**else**:
data[self.name]['status'] = **True**
f.seek(0)
f.truncate()
json.dump(data, f)
print('----welcome----')
**break**
**else**:
data[self.name]['timeout']=time.time()
f.seek(0)
f.truncate()
json.dump(data,f)
**def** **quit**(self):
**with** open(self.name+'.txt', 'r+', encoding='utf-8') **as** f:
data = json.load(f)
**if** data[self.name]['status'] == **True**:
data[self.name]['status'] = **False**
f.seek(0)
f.truncate()
json.dump(data, f)
**else**:
print('您是退出状态!')
alex=User(‘alex’,‘123’)
egon=User(‘egon’,‘456’)
# alex.save()
# egon.save()
# print(alex.db)
# print(egon.db)
# alex.login()
alex.quit()
# egon.quit()
print(alex.db)
print(egon.db)
alex.login()
egon.login() json
import time
class User:
def __init__(self, name, password):
self.name = name
self.password = password
self.status = False
self.timeout = 0
@property
def db(self):
with open(self.name+‘.txt’, ‘r’, encoding=‘utf-8’) as f:
data = json.load(f)
return data
**def** **save**(self):
obj={}
obj[self.name]={'password':self.password,'status':self.status,'timeout':self.timeout}
**with** open(self.name+'.txt', 'w', encoding='utf-8') **as** f:
json.dump(obj,f)
**def** **login**(self):
**with** open(self.name+'.txt', 'r+', encoding='utf-8') **as** f:
data = json.load(f)
count = 0
**while** count < 3:
password = input('password>>:').strip()
**if** password != data[self.name]['password']:
count += 1
**continue**
**else**:
**if** data[self.name]['timeout'] != 0:
**if** time.time() - data[self.name]['timeout'] > 10:
print('不允许登录了!超时')
**break**
**else**:
data[self.name]['status'] = **True**
f.seek(0)
f.truncate()
json.dump(data, f)
print('----welcome----')
**break**
**else**:
data[self.name]['status'] = **True**
f.seek(0)
f.truncate()
json.dump(data, f)
print('----welcome----')
**break**
**else**:
data[self.name]['timeout']=time.time()
f.seek(0)
f.truncate()
json.dump(data,f)
**def** **quit**(self):
**with** open(self.name+'.txt', 'r+', encoding='utf-8') **as** f:
data = json.load(f)
**if** data[self.name]['status'] == **True**:
data[self.name]['status'] = **False**
f.seek(0)
f.truncate()
json.dump(data, f)
**else**:
print('您是退出状态!')
alex=User(‘alex’,‘123’)
egon=User(‘egon’,‘456’)
# alex.save()
# egon.save()
# print(alex.db)
# print(egon.db)
# alex.login()
alex.quit()
# egon.quit()
print(alex.db)
print(egon.db)
alex.login()
egon.login()
23,用面向对象的形式编写一个老师角色, 并实现以下功能, 获取老师列表, 创建老师、删除老师、创建成功之后通过 pickle 序列化保存到文件里,并在下一次重启程序时能读取到创建的老师, 例如程序目录结构如下.
.
|-- bin/
| |-- main.py 程序运行主体程序(可进行菜单选择等)
|-- config/
| |-- settings.py 程序配置(例如: 配置存储创建老师的路径相关等)
|-- db 数据存储(持久化, 使得每次再重启程序时, 相关数据对应保留)
| |-- teachers/ 存储所有老师的文件
| |-- … …
|-- src/ 程序主体模块存放
| |-- __init__.py
| |-- teacher.py 例如: 实现老师相关功能的文件
| |-- group.py 例如: 实现班级相关的功能的文件
|-- manage.py 程序启动文件
|-- README.md 程序说明文件-- bin/
| |-- main.py 程序运行主体程序(可进行菜单选择等)
|-- config/
| |-- settings.py 程序配置(例如: 配置存储创建老师的路径相关等)
|-- db 数据存储(持久化, 使得每次再重启程序时, 相关数据对应保留)
| |-- teachers/ 存储所有老师的文件
| |-- … …
|-- src/ 程序主体模块存放
| |-- __init__.py
| |-- teacher.py 例如: 实现老师相关功能的文件
| |-- group.py 例如: 实现班级相关的功能的文件
|-- manage.py 程序启动文件
|-- README.md 程序说明文件
24,根据23 题, 再编写一个班级类, 实现以下功能, 创建班级, 删除班级, 获取班级列表、创建成功之后通过 pickle 序列化保存到文件里,并在下一次重启程序时能读取到创建的班级.
25,根据 23题, 编写课程类, 实现以下功能, 创建课程(创建要求如上), 删除课程, 获取课程列表
26,根据23 题, 编写学校类, 实现以下功能, 创建学校, 删除学校, 获取学校列表
27,通过23题, 它们雷同的功能, 是否可以通过继承的方式进行一些优化
伪代码
class Behavior(object):
**def** **fetch**(self, keyword):
通过 keyword 参数 查询出对应的数据列表
class School(Behavior):
**pass**
class Teacher(Behavior):
**pass**
s = School()
t = Teacher()
s.fetch(“school”)
t.fetch(“teacher”)class Behavior(object):
**def** **fetch**(self, keyword):
通过 keyword 参数 查询出对应的数据列表
class School(Behavior):
**pass**
class Teacher(Behavior):
**pass**
s = School()
t = Teacher()
s.fetch(“school”)
t.fetch(“teacher”)
28:编写一个学生类,产生一堆学生对象
要求:有一个计数器(属性),统计总共实例了多少个对象
class Studentclass:
school = ‘jiaotong university’
count = 0
**def** **\_\_init\_\_**(self,name,age,sex):
self.name = name
self.age = age
self.sex =sex
Studentclass.count +=1
**def** **learn**(self):
print('%s is learning'%self.name)
stu1 = Studentclass(‘james’,23,‘male’)
stu2 = Studentclass(‘poal’,24,‘male’)
stu3 = Studentclass(‘harden’,25,‘male’)
print(Studentclass.count)
print(stu1.dict)
print(stu2.dict)
print(stu3.dict)
print(stu1.count)
print(stu2.count)
print(stu3.count) Studentclass:
school = ‘jiaotong university’
count = 0
**def** **\_\_init\_\_**(self,name,age,sex):
self.name = name
self.age = age
self.sex =sex
Studentclass.count +=1
**def** **learn**(self):
print('%s is learning'%self.name)
stu1 = Studentclass(‘james’,23,‘male’)
stu2 = Studentclass(‘poal’,24,‘male’)
stu3 = Studentclass(‘harden’,25,‘male’)
print(Studentclass.count)
print(stu1.dict)
print(stu2.dict)
print(stu3.dict)
(1)Python所有方向的学习路线(新版)
这是我花了几天的时间去把Python所有方向的技术点做的整理,形成各个领域的知识点汇总,它的用处就在于,你可以按照上面的知识点去找对应的学习资源,保证自己学得较为全面。
最近我才对这些路线做了一下新的更新,知识体系更全面了。
(2)Python学习视频
包含了Python入门、爬虫、数据分析和web开发的学习视频,总共100多个,虽然没有那么全面,但是对于入门来说是没问题的,学完这些之后,你可以按照我上面的学习路线去网上找其他的知识资源进行进阶。
(3)100多个练手项目
我们在看视频学习的时候,不能光动眼动脑不动手,比较科学的学习方法是在理解之后运用它们,这时候练手项目就很适合了,只是里面的项目比较多,水平也是参差不齐,大家可以挑自己能做的项目去练练。
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!