Python基础语法

Python基础知识

注意：图片无法显示，请通过图片的url地址访问

一、下载安装

官网下载地址：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、运算符

逻辑运算符

名称	用法
or	有一个为真，则为真
and	有一个为假，则为假
not	否定作用

比较运算符

符号	用法
<	小于
>	大于
=	等于
<=	小于等于
>=	大于等于
!=	不等于

算术运算符

符号	用法
*	乘法
+	加法
-	减法
/	除法
//	整除运算
%	取余运算
**	幂运算

布尔运算符

类型	作用	范围
True	真	除False外都为真
False	假	空列表、空元组、空字典，空集合，0，空字符串等

四、类和函数

函数

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

异常名称	描述
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	用户代码生成的警告

六、文件管理

文件读写

文件打开

相对路径：在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模块

方法	含义
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	返回文件所在目录

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	当前线程信息

七、模块和包

模块

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

导包

import 包名 # 导入模块

import 模块名 as 别名

from 模块名 import 成员名 as 别名

from 模块名 import 成员名

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