Python基础知识
一、下载安装
官网下载地址：https://www.python.org/downloads
下载后执行安装文件，按照默认安装顺序即可。然后在命令行中输入python，检查是否安装完成。如果出现以下内容，则证明安装成功。
二、编译器
支持python的编译器有很多，
我个人使用pycharm，其功能齐全，唯一的缺点的收费。
或者Visual Studio Code也是一个不错的选择.
三、基础知识
1、数据类型
数据类型包括：字符串（string）、整数类型（int）、浮点数（float）、布尔类型（boolean）[其中float(‘inf’)代表正无穷，float(‘-inf’)代表负无穷]。其关系如图：
2、条件判断
if语句可以通过判断条件是否成立来决定是否执行某个语句
if···else···
if···elif······else···
"""用法如下"""
weather = '天晴'
if weather == '下雨':
print('在家学习')
elif weather == '阴天':
print('去钓鱼')
elif weather == '暴风雨':
print('保命')
else:
print('去逛街')
# 特殊的三目运算
a = 3
print(True) if a>5 else print(False)
3、循环语句
3.1 for循环
for 变量名 in 可遍历对象:
声明操作
else: # 循环结束才会去执行，可以省略！
声明操作
for i in range(10):
print(i)
else:
print("finished")
3.2 while循环
while 循环条件:
声明操作
else: # 循环结束才会去执行，可以省略！
声明操作
while i<= 5:
print(i)
i += 1
else:
print('finished')
# 死循环
while True:
pass
# 99乘法表的制作
num1 = 1
while num1 <= 9:
num2 = 1
while num2 <= num1:
print(f'{num1}*{num2}={num1 * num2:<2} ', end='')
num2 += 1
print('')
num1 += 1
3.3 结束循环
continue：跳出当前循环
break：终止全部循环
4、运算符
4.1 逻辑运算符
| 名称 | 用法 |
|---|---|
| or | 有一个为真，则为真 |
| and | 有一个为假，则为假 |
| not | 否定作用 |
4.2 比较运算符
| 符号 | 用法 |
|---|---|
| < | 小于 |
| > | 大于 |
| = | 等于 |
| <= | 小于等于 |
| >= | 大于等于 |
| != | 不等于 |
4.3 算术运算符
| 符号 | 用法 |
|---|---|
| * | 乘法 |
| + | 加法 |
| - | 减法 |
| / | 除法 |
| // | 整除运算 |
| % | 取余运算 |
| ** | 幂运算 |
4.4 布尔运算符
| 类型 | 作用 | 范围 |
|---|---|---|
| True | 真 | 除False外都为真 |
| False | 假 | 空列表、空元组、空字典，空集合，0，空字符串等 |
四、类和函数
1、 函数
def 函数名(): # 函数的命名用驼峰命名法
函数体
函数名() #函数的调用：直接函数名加括号就是在调用函数，函数在调用时会执行函数里面的函数体
def fun(): # 定义一个函数 print("This a function") fun() # 调用函数
1.1 函数参数
形参：在函数体内用到的参数
必备参数：函数在调用是必须要传入的参数,给了几个参数就必须传几个参数值
关键字参数：指定参数名来传参数值
不定长参数（默认参数，可以不写）：接受的参数值不定，传多少，这个不定长参数就接受多少
一个号是元组不定长参数*args，两个**是字典不定长参数**kwargs
函数的注释 -> 提示：在help函数查看时可以看到
def func(*args, **kwargs) -> "define function":
print(args, 'and ', kwargs)
func(1, 2, 3, a=1, d=2, c=3) # 其中，a=1是关键字参数，
1.2 函数的作用域
函数内部的变量不能被函数外面使用，除非通过return返回
num1 = 20 # 这是全局变量
def func2():
global num1 # global 关键字声明全局变量
num1 = num1+1
print(num1)
print(num1)
闭包里面的局部变量
def func():
num2 = 30 # 这是局部变量
def func1():
nonlocal num2 # nonlocal 关键字声明局部变量
num2 = num2+1
print(num2)
def func2():
print(num2)
return func1,func2 # 外层函数返回内层函数的函数体
a,b = func() #a = func1 a() func1()
1.3 特殊函数
递归函数：函数自身调用自己
def recursion(n):
if n <= 1: # 递归结束的条件
return 1 # 结束返回1
else:
return n * recursion(n-1) # 一直调用自己 5*4*3*2*1
print(recursion(5))
匿名函数：用在那些只使用一次的场景中，程序中只需要调用一次某个简单逻辑。
def g(x):
x = str(x)
return x
print(g(2))
# 转换成匿名函数
g = lambda x:x+1 # x就是函数g要传入的参数值，冒号后面就是对传入的参数做的操作
g(4) # 匿名函数调用和函数一样
匿名函数也可以用在列表中
list1 = [2,'3',1,'4',7,'9',5]
list1.sort()
list1.sort(key=lambda x:int(x),reverse=False)
print(list1)
2、 类
2.1 初级面向对象
面向对象的基本概念：类、属性、方法
类：黑白黄三种人，人类
属性：自身存在的，名字、性别、身高、体重、肤色，静态属性
方法：人会走路、吃饭、玩，动态属性
name1 = '小' # 变量
class Person: # class 帕斯卡命名法 PersonList
name = '子' # 定义在类里面的变量称之为属性
age = 18
def play(self,name): # 定义在类里面的函数称之为方法,self指实例化对象本身 self=zilin
print(f'{name}正在玩游戏')
def search(self,name):
print(f'{name}正在查资料')
zilin = Person() # 实例化类，创建一个对象，实例化成一个具体的人
bd = Person() # 创建第二个实例化对象bd
bd.name = '北斗' # 重新给bd这个人给予一个名字
2.1.2 初始化变量
初始化函数__init__ 对属性重新赋值，让每个人拥有自己独有的属性
class Student:
def __init__ (self, name, age): # self指实例化对象本身 ，实例化对象是自动调用一次
self.name = name # 等号后面的是实例化的属性
self.age=age
def play(self): # 定义在类里面的函数称之为方法,self指实例化对象本身 self=zilin
print(f'{self.name}正在玩游戏') #bd.name
def search(self):
print(f'{self.name}正在查资料') # bd.name
def __del__(self): # 析构函数__del__：让对象在删除时输出一句话,删除对象自动调用
print(f'{self.name}被删除了')
stu = Student(bd, 18) # 实例化对象时吗，就应该相对应的给初始化函数传参
stu.play()
stu.search()
del stu # 删除stu这个实例化对象
2.1.3 类的继承
class Student:
def __init__ (self, name, age): # self指实例化对象本身 ，实例化对象是自动调用一次
self.name = name # 等号后面的是实例化的属性
self.age=age
def play(self): # 定义在类里面的函数称之为方法,self指实例化对象本身 self=zilin
print(f'{self.name}正在玩游戏') #bd.name
def eat(self):
print(f'{self.name}正在吃饭') # bd.name
def __del__(self): # 析构函数__del__：让对象在删除时输出一句话,删除对象自动调用
print(f'{self.name}被删除了')
class StuYear(Student): # 继承Student中的所有方法
def __init__(self, name, age, year):
super().__init__(name, age) # 继承Student类的实例化对象
self.year = year
def study(self):
print("name:", self.name, "age:", self.age, "year:", self.year)
def eat(self):
Student.eat(self) # 指定类去使用里面的方法
super().eat() # 让重写发的子类拥有父类的方法
print(f'{self.name}爱吃辣')
stu = StuYear('li', 20, 20)
stu.study()
stu.play()
StuYear.eat(self=stu)
2.1.4 多继承
使用’'类名.mro()"方法查看继承顺序
class A:
pass
class B:
pass
class C:
pass
class D(A, B, C): # 调用顺序为A, B, C
pass
print(D.mro()) # 查看继承顺序
2.2 高级面向对象
2.2.1 魔法方法
魔法方法具体讲解：https://www.cnblogs.com/liuzhongkun/p/16807992.html
class Person:
def __init__(self,name):
self.name = name
def eat(self):
print(f'{self.name}在吃饭')
kun = Person('kun')
hasattr(kun,'name') # 判断属性是否存在
getattr(kun,'name') # 得到属性值，没有则报错
setattr(kun,'name','一') # 设置属性值，有则改，无则加
delattr(kun,'name') # 删除属性
issubclass(Person,object) # issubclass 判断第一个类是不是后面类的子类
isinstance(zilin,Person) # isinstance 判断实例是否是后面类的实例对象
isinstance(1,(str,int,float)) # 还可以用来判断数据类型
type(zilin) == Person # 只能判断单个类实例化衍生
__new__方法：new魔法方法创建实例化对象，以及如何让init初始化方法拥有参数去使用
class Person:
def __new__(obj,*args,**kwargs): #object祖宗类，new方法才是帮我们创建实例化对象的一个方法
print('new实例方法')
return object.__new__(obj) # Person.eat(self)
def __init__(self,name):
print('init自动调用')
self.name = name
zilin = Person('kun')
单例模式 ： 创建的所有的实例化对象都是同一个对象
class Person:
def __new__(obj,*args,**kwargs): # object祖宗类，new方法才是帮我们创建实例化对象的一个方法
if not hasattr(obj,'_instance'): # not取反返回True，判断祖宗类object里面有没有这个_instance
#通过属性限制他去创建多个新的实例对象
obj._instance = object.__new__(obj) #object.__new__(obj) 生成一个新的实例化对象
return obj._instance #返回实例化对象
def __init__(self,name):
print('init自动调用')
self.name = name
z = Person('z') # 立第一个实例化对象会在object类去创建一个_instance属性
b = Person('b') # 建第二个实例化对象判断属性存在返回第一个实例化对象
y = Person('y') # 第三个实例化对象判断属性存在还是返回第一个实例化对象
z==b==y # 上创建的都是同一个实例对象
输出魔法方法 __str__ __repr__
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self): # 针对print输出魔法方法
return f'这个是{self.name}的str魔法方法'
def __repr__(self): # 直接输出实例对象时会调用
return f'这个是{self.name}的repr魔法方法'
z = Person('z',18)
z # repr方法调用
print(z) # str方法调用
__call__方法：让实例对象像函数一样去调用
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def __call__(self,x,y):
return x+y
z = Person('z',18)
z(1, 2)
2.2.2 协议
序列协议
li = (1,2,3,4)
class IndexTuple:
def __init__(self,*args): # args元组不定长参数拿到是一个元组
self.values = args
self.index = tuple(enumerate(self.values)) # 通过枚举enumerate的方法将下标索引和自身的元素组成一个大大的元组
print(self.index)
def __len__(self):
return len(self.values)
def __getitem__(self,key): # 通过下标索引key取值
return self.index[key]
return self.values[key]
def __repr__(self):
return str(self.values) # 只能返回字符串
my_t = IndexTuple(1,2,3,34)
可迭代对象 --> 取值，像字符串，元组，列表，集合，字典能够被如循环取值一个一个拿取到元素的数据类型
li = [1,2,3,4,5] # 可迭代对象
li1 = iter(li) # 将可迭代对象转成一个迭代器对象，迭代器对象就是能够被next一个一个将值取出
next(li1)
迭代器协议
class Number:
def __init__(self,end):
self.start = 0
self.end = end
def __iter__(self): #构建一个迭代器对象
return self
def __next__(self): #对迭代器对象取值
self.start += 1
if self.start <= self.end: #当self.start值小于self.end
return self.start #返回self.start
else:
raise StopIteration #抛出终止迭代异常
nu = Number(6)
for i in nu:
print(i)
# 也可以用next(nu)函数去调用
上下文协议： 计时器，所谓的秒表，检测代码运行时长
import time #时间模块
class RunTime:
def __enter__(self): #接收代码开始时间
self.star_time = time.time() #获得当前开始时间
return self.star_time
def __exit__(self,exc_type,exc_val,exc_tb):
self.end_time = time.time() #获取当前结束时间
self.run_time = self.end_time - self.star_time #代码运行时间
print('代码运行时间为：',self.run_time)
with RunTime(): #使用方法
# 要执行的代码，运行时长
pass
2.2.3 生成器和装饰器
生成器等同于迭代器 yield 关键字返回值 next获取值
生成器详解：https://www.cnblogs.com/liuzhongkun/p/16212744.html
def func():
print(1)
yield 2 # 和return一样有一个暂停函数的功能，并且遇到下一个next会继续向下执行
print(3)
yield 4
print(5)
yield 6
a = func()
for i in a:
print(i)
# 或者使用next(a)，通过next获取值得到返回值
装饰器：闭包加回调函数
装饰器具体讲解：https://blog.csdn.net/qq_62789540/article/details/124513178
def fun(x):
def fun1(aa, bb):
print(aa, 'and:', bb)
return x(1, 2)
print('外层函数')
return fun1
@fun
def func(cc, dd):
print('这是func的值：', cc, dd)
func(3, 4)
内置装饰器：
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
@classmethod # 第一个参数自动传入类
def learn(cls): # cls=Person
print(f'{zl.name}在学习')
print(cls)
@staticmethod #不在自动传入self
def sleep():
print(zl.name)
print('在睡觉')
zl = Person('z',18)
Person.learn()
Person.sleep()
五、常用操作
1、 格式化操作
%方式
format方法
2、 常用函数
print()：输出函数
input()：输入函数
type()：查看数据类型
id()：查看内存地址
eval()：去除双引号
3、 异常信息
try: pass except Exception as e: # 保错后键异常信息存储在e中 pass finally: # 无论报不报错都运行 pass
| 异常名称 | 描述 |
|---|---|
| BaseException | 所有异常的基类 |
| SystemExit | 解释器请求退出 |
| KeyboardInterrupt | 用户中断执行(通常是输入^C) |
| GeneratorExit | 生成器(generator)发生异常来通知退出 |
| Exception | 常规错误的基类 |
| StopIteration | 迭代器没有更多的值 |
| StandardError | 所有的内建标准异常的基类 |
| ArithmeticError | 所有数值计算错误的基类 |
| FloatingPointError | 浮点计算错误 |
| OverflowError | 数值运算超出最大限制 |
| ZeroDivisionError | 除(或取模)零 (所有数据类型) |
| AssertionError | 断言语句失败 |
| AttributeError | 对象没有这个属性 |
| EOFError | 没有内建输入,到达EOF 标记 |
| EnvironmentError | 操作系统错误的基类 |
| IOError | 输入/输出操作失败 |
| OSError | 操作系统错误 |
| WindowsError | 系统调用失败 |
| ImportError | 导入模块/对象失败 |
| LookupError | 无效数据查询的基类 |
| IndexError | 序列中没有此索引(index) |
| KeyError | 映射中没有这个键 |
| MemoryError | 内存溢出错误(对于Python 解释器不是致命的) |
| NameError | 未声明/初始化对象 (没有属性) |
| UnboundLocalError | 访问未初始化的本地变量 |
| ReferenceError | 弱引用(Weak reference)试图访问已经垃圾回收了的对象 |
| RuntimeError | 一般的运行时错误 |
| NotImplementedError | 尚未实现的方法 |
| SyntaxError | Python 语法错误 |
| IndentationError | 缩进错误 |
| TabError | Tab 和空格混用 |
| SystemError | 一般的解释器系统错误 |
| TypeError | 对类型无效的操作 |
| ValueError | 传入无效的参数 |
| UnicodeError | Unicode 相关的错误 |
| UnicodeDecodeError | Unicode 解码时的错误 |
| UnicodeEncodeError | Unicode 编码时错误 |
| UnicodeTranslateError | Unicode 转换时错误 |
| Warning | 警告的基类 |
| DeprecationWarning | 关于被弃用的特征的警告 |
| FutureWarning | 关于构造将来语义会有改变的警告 |
| OverflowWarning | 旧的关于自动提升为长整型(long)的警告 |
| PendingDeprecationWarning | 关于特性将会被废弃的警告 |
| RuntimeWarning | 可疑的运行时行为(runtime behavior)的警告 |
| SyntaxWarning | 可疑的语法的警告 |
| UserWarning | 用户代码生成的警告 |
六、文件管理
1、 文件读写
文件打开
相对路径：在py脚本文件同级目录下的文件 .\同级目录 …\上级目录
绝对路径：完整的路径
文件读写mode
a追加模式下，如果文件不存在，也会自动帮我们创建一个文件，之后在写入内容
和w只写的区别就是一个是清空再写入，一个是继续向后写
文件操作
打开
file = open(“FilePath”, mode=“type”(, encoding=“”)) # 要记得关闭文件
pass
file.close()
with open(“FilePath”, mode=“type”(, encoding=“”)) # 上下文管理器打开，可以不用关闭
写入
file.writre(“content”) # write()方法：需要传入一个字符串做为参数,否则会报错
file.writelines() # writelines()方法：既可以传入字符串又可以传入一个字符序列,并将该字符序列写入文件
读取
file.read() # read()方法：一次性读如并返回文件的所有内容
file.readlines() # readlines()方法：每次读取一行；返回的是一个字符串对象，保持当前行的内存。一次性读取整个文件；自动将文件内容分析成一个行的列表
遍历读取
- 文件对象本身可以迭代，并且以行的形式读取
for i in file: print(i)指针
file.tell() # tell()方法：返回文件的当前位置，即文件指针当前位置。
file.seek() # seek()方法：用于移动文件读取指针到指定位置。
- seek第一个参数：移动的长度（字节）；如果该值为负数，表示从后往前移动n个字节
- seek第二个参数：0从开头（默认），1从当前，2从末尾
2、 OS模块
| 方法 | 含义 |
|---|---|
| os.sep | 符合当前系统的路径分割符，Linux/windows\ |
| os.name | 返回操作系统类型windows“nt”Linux“posix” |
| os.rename | 更改文件名，传递两个参数（旧文件名，新文件名） |
| os.getcwd | 返回当前的工作目录 |
| os.listdir | 列出指定目录下的目录和文件 |
| os.chdir | 修改当前的工作路径 |
| os.mkdir | 创建目录 |
| os.makedirs | 递归创建目录 |
| os.remove | 删除文件 |
| os.rmdir | 删除文件夹（文件夹下内容为空） |
| os.removedirs | 递归删除文件夹 |
| os.system | 执行系统命令 |
| os.popen | 执行系统命令，会将结果以文件的形式返回 |
| os.walk | 通过在目录树中游走输出在目录中的文件名，向上或者向下 |
| os.path.join | 连接目录和文件名。os.path.join（path,name） |
| os.path. isfile | 判断指定对象是否为文件。是返回True,否则False |
| os.path.isdir | 判断指定对象是否为目录。是True,否则False |
| os.path. split | 返回路径的目录和文件名 |
| os.path. exists | 检验指定的对象是否存在。是True,否则False |
| os.path.getsize | 获取指定对象的文件大小 |
| os.path.abspath | 获得绝对路径 |
| os.path.basename | 返回文件名 |
| os.path.dirname | 返回文件所在目录 |
3、 sys模块
| 方法 | 含义 |
|---|---|
| sys.argv | 获取命令行参数列表，第一个元素是程序本身 |
| sys.exit(n) | 退出Python程序，exit(0)表示正常退出。当参数非0时，会引发一个SystemExit异常，可以在程序中捕获该异常 |
| sys.version | 获取Python解释程器的版本信息 |
| sys.maxsize | 最大的Int值，64位平台是2**63 - 1 |
| sys.path | 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 |
| sys.platform | 返回操作系统平台名称 |
| sys.stdin | 输入相关 |
| sys.stdout | 输出相关 |
| sys.stderr | 错误相关 |
| sys.exc_info() | 返回异常信息三元元组 |
| sys.getdefaultencoding() | 获取系统当前编码，默认为utf-8 |
| sys.setdefaultencoding() | 设置系统的默认编码 |
| sys.getfilesystemencoding() | 获取文件系统使用编码方式，默认是utf-8 |
| sys.modules | 以字典的形式返回所有当前Python环境中已经导入的模块 |
| sys.builtin_module_names | 返回一个列表，包含所有已经编译到Python解释器里的模块的名字 |
| sys.copyright | 当前Python的版权信息 |
| sys.flags | 命令行标识状态信息列表。只读。 |
| sys.getrefcount(object) | 返回对象的引用数量 |
| sys.getrecursionlimit() | 返回Python最大递归深度，默认1000 |
| sys.getsizeof(object[, default]) | 返回对象的大小 |
| sys.getswitchinterval() | 返回线程切换时间间隔，默认0.005秒 |
| sys.setswitchinterval(interval) | 设置线程切换的时间间隔，单位秒 |
| sys.getwindowsversion() | 返回当前windwos系统的版本信息 |
| sys.hash_info | 返回Python默认的哈希方法的参数 |
| sys.implementation | 当前正在运行的Python解释器的具体实现，比如CPython |
| sys.thread_info | 当前线程信息 |
七、模块和包
1、 模块
其是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
2、 导包
import 包名 # 导入模块
import 模块名 as 别名
from 模块名 import 成员名 as 别名
from 模块名 import 成员名
from 模块名 import * # 从模块中导入所有方法
同时，还可以使用__import__动态导入第三方库，其为一个魔法方法。
160
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
