• Python基础知识
  • 一、下载安装
  • 二、编译器
  • 三、基础知识
    • 1、数据类型
    • 2、条件判断
    • 3、循环语句
      • for循环
      • while循环
      • 结束循环
    • 4、运算符
      • 逻辑运算符
      • 比较运算符
      • 算术运算符
      • 布尔运算符
  • 四、类和函数
    • 函数
      • 函数参数
      • 函数的作用域
      • 特殊函数
    • 类
      • 初级面向对象
        • 初始化变量
        • 类的继承
          • 多继承
      • 高级面向对象
        • 魔法方法
        • 协议
        • 生成器和装饰器
  • 五、常用操作
    • 格式化操作
    • 常用函数
    • 异常信息
  • 六、文件管理
    • 文件读写
    • OS模块
    • sys模块
  • 七、模块和包
    • 模块
    • 导包

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、循环语句

for循环

for 变量名 in 可遍历对象:
声明操作
else: # 循环结束才会去执行，可以省略！
声明操作

for i in range(10):
    print(i)
else:
    print("finished")

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

结束循环

continue：跳出当前循环

break：终止全部循环

4、运算符

逻辑运算符

比较运算符

算术运算符

布尔运算符

四、类和函数

函数

def 函数名(): # 函数的命名用驼峰命名法

​ 函数体

函数名() #函数的调用：直接函数名加括号就是在调用函数，函数在调用时会执行函数里面的函数体

def fun():  # 定义一个函数
    print("This a function")
    
    
fun()  # 调用函数

函数参数

形参：在函数体内用到的参数

必备参数：函数在调用是必须要传入的参数,给了几个参数就必须传几个参数值

关键字参数：指定参数名来传参数值

不定长参数（默认参数，可以不写）：接受的参数值不定，传多少，这个不定长参数就接受多少
一个号是元组不定长参数*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是关键字参数，

函数的作用域

函数内部的变量不能被函数外面使用，除非通过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()

特殊函数

递归函数：函数自身调用自己

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)

类

初级面向对象

面向对象的基本概念：类、属性、方法

类：黑白黄三种人，人类
属性：自身存在的，名字、性别、身高、体重、肤色，静态属性
方法：人会走路、吃饭、玩，动态属性

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这个人给予一个名字

初始化变量

初始化函数__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这个实例化对象

类的继承

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)

多继承

使用''类名.mro()"方法查看继承顺序

class A:
    pass

class B:
    pass

class C:
    pass

class D(A, B, C):  # 调用顺序为A, B, C
    pass

print(D.mro())  # 查看继承顺序

高级面向对象

魔法方法

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)

协议

序列协议

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

生成器和装饰器

生成器等同于迭代器 yield 关键字返回值 next获取值

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获取值得到返回值

装饰器：闭包加回调函数

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()

五、常用操作

格式化操作

%方式

format方法

常用函数

print()：输出函数

input()：输入函数

type()：查看数据类型

id()：查看内存地址

eval()：去除双引号

异常信息

try:

​ pass

except Exception as e: # 保错后键异常信息存储在e中

​ pass

finally: # 无论报不报错都运行

​ pass

六、文件管理

文件读写

文件打开

相对路径：在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从末尾

OS模块

sys模块

七、模块和包

模块

其是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

导包

import 包名 # 导入模块

import 模块名 as 别名

from 模块名 import 成员名 as 别名

from 模块名 import 成员名

from 模块名 import * # 从模块中导入所有方法