Python语法速通

前言

本篇博客主要是基于马士兵Python语法课程学习的笔记和总结，从编程基础、数据类型和运算符、流程控制、组合数据类型、字符串、函数、Bug、面向对象、模块和包、文件操作十个方面展开，对Python的特性部分详细描述并用样例辅助理解，方便各位速通Python语法亦或者作为学习Python的提纲。

一、Python编程基础

1.print函数的使用

• print完整的语法格式

print(value,...,sep=' ',end='\n',file=None)

• 换行的形式

print('北京欢迎你！')
print("北京欢迎你！")

• 单print不换行的形式（非字符串）

print(a,b,'学习')

• 单print不换行的形式（都是字符串）

print('北京欢迎你'+'2023')

• 多个print不换行的形式

print('北京',end='-->')
print('欢迎你')

• 文件的写入

fp=open('note.txt','w')
print('北京欢迎你')
fp.close()

2.input函数的使用

• input语法结构:x=input('提示文字')
• 注意：无论输入的数据是什么，x的数据类型都是字符串类型，有时需要用强制类型转换，比如int(num)

3.注释

• 单行注释用：#
• 多行注释用：一对三单引号或一对三双引号
• 中文文档声明注释：#coding=utf-8（必须在第一行）

二、数据类型和运算符

1.标识符命名规范

• 模块名：全部小写字母，下划线分隔多个字母
• 包名：全部小写字母，不推荐使用下划线
• 类名：单词首字母大写形式（Pascal风格）
• 模块内部的类：“_”+Pascal风格
• 函数、类的属性、方法：全部小写字母，下划线分隔多个字母
• 常量：全部大写字母，可以使用下划线
• 使用"_"开头的模块变量或者函数是受保护的，在使用"from xxx import*"语句从模块中导入时，这些模块变量或函数不能被导入
• 使用"__"开头的实例变量或方法是类私有的
• 以双下划线开头和结尾的是Python的专用标识

2.变量与常量

• 变量赋值会自动识别类型
• 可以动态改变变量数据类型

n=7
print(type(n))#<class 'int'>
n='欢迎你'
print(type(n))#<class 'str'>

• 允许多个变量指向同一个值
• 常量：全部大写字母，可以使用下划线，不要修改

3.数据类型

• 整数型使用

num1=987#使用十进制存储
num2=0b1010101#使用二进制存储
num3=0o765#使用八进制存储
num4=0x878ABF#使用十六进制存储

• 浮点型使用

x=1.99E1413#科学计数法用浮点型存储

y=123+456j#复数用浮点数存储实部和虚部
print('实数部分',y.real)
print('虚数部分',y.imag)

• 字符串类型使用

单行字符串用" "或者‘ ’
多行字符串用""" """或者''' '''

操作符	描述说明
x + y	将字符串x与y连接起来
x * n	复制n次字符串x
x in s	如果x是s的字串，结果为True,否则结果为False

• 布尔类型
• 类型转换

#对字符串：将str转成int或float类型进行计算
print(int('100')+int('200'))#输出是300

#对字符：chr()和ord()一对相反操作
print(ord('杨'))#输出26472
print(chr(26472))#输出杨

#进制转换：十进制和其他进制转换
print('十进制-->二进制',bin(26472))
print('十进制-->八进制',oct(26472))
print('十进制-->十六进制',hex(26472))

#类型转换函数eval(str),常与input一起使用获得输入数值
s='3.14+3'
x=eval(s)#输出6.14，eval去掉引号并进行执行

4.运算符

运算符	描述说明	示例
//	整除	10//3=3
%	取余	10%3=1
**	幂运算	2**4=16
and	逻辑与	从左到右结合
or	逻辑或	从左到右结合
not	逻辑非	从右到左结合
&	位与	看作二进制数按位与
|	位或	看作二进制数按位或
<<	左移位	左溢出，右补0
>>	右移位	右溢出，最高位0左补0，最高位1左补1

三、程序流程控制

1.选择结构

#if-else结构
if 表达式1：
     语句块1
elif 表达式2：
     语句块2
else:
     语句块3
#多个判断条件可以用and和or，取非可以用not

#match-case结构
match 值：
    case 值1：
         语句块1
    case 值2：
         语句块2
    case 值3：
         语句块3

2.循环结构

#for-else结构
for 循环变量 in 遍历对象：
   语句块1
else:#循环正常结束后执行
   语句块2
#常在遍历对象上使用rang(i,j)产生一个[i,j)的整数序列

#while结构
while 表达式：
   语句块1
else:
   语句块2
#以上两种结构都可以使用break和continue

#空语句用pass代替语句块，防止报错

四、组合数据类型

1.序列的操作

• 序列包含了列表、元组（不可变字符序列）、字典、集合、字符串（不可变字符序列）
• 序列的切片操作：序列[start:end:step],开始默认是0包含，结尾不包含（如果不写默认是最后一个且包含），步长默认是1

s='HelloWorld'
s1=s[0:5:2]
print(s1)#输出Hlo

• 其他序列操作

操作符/函数	描述说明
x + y	将序列x与y连接起来
x * n	复制n次序列x
x in s	如果x是s的元素，结果为True,否则结果为False
x not in s	和上面的相反
len(s)	序列s中元素的个数（序列的长度）
max(s)	序列s中元素的最大值
min(s)	序列s中元素的最小值
s.index(x)	序列s中第一次出现元素x的位置（索引位置，从0开始）
s.count(x)	序列s中出现x的总次数

• 3.11新特性：结构模式匹配match，同步迭代

2.列表

• 创建与删除

#使用[]直接创建列表
列表名=[element1,element2,...,elementN]
#例子：
lst=['hello','world',98,100,5]

#使用内置函数list()创建列表
列表名=list(序列)
#例子：
lst1=list('hello')#['h','e','l','l','o']
lst2=list(range(1,10,2))#[1,3,5,7,9]

#列表生成式
lst=[expression for item in range]
lst=[expression for item in range if condition]
#例子：
lst=[random.randint(1,100) for _ in range(10)]

#列表的删除
del 列表名

• 修改

lst[修改元素的索引]=修改后的值

• 遍历

#使用for和元素
for item in lst:
    print(item)

#使用for和索引
for i in range(0,len(lst)):
    print(i,lst[i])

#使用enumerate函数
for index,item in enumerate(lst):
    print(index,item)
    #index是序号不是索引
    #可以手动修改起始值，例如：for index,item in enumerate(lst，start=1):，start可以省略

• 列表的排序

#sort方法，不产生新的列表对象
lst.sort(key=None,reverse=False)
#key表示排序的规则
#reverse表示排序方式，默认升序

#内置函数sorted()，产生新的列表对象
lst2=sorted(iterable,key=None,reverse=False)
#iterable表示排序的对象

#不仅数字可以排序，字符串按照ASCLL码排序

• 列表的其他相关操作

列表的方法	描述说明
lst.append(x)	在列表lst最后增加一个元素x
lst.insert(index,x)	在列表中第index位置增加一个元素
lst.clear()	清除列表lst中所有元素
lst.pop(index)	将列表lst第index位置的元素取出，并从列表中删除
lst.remove(x)	将列表lst中出现的第一个元素x删除
lst.reverse()	将列表lst中的元素反转
lst.copy()	拷贝列表lst中的所有元素，生成一个新的列表

• 二维列表

#创建
lst=[
    ['城市'，'环比','同比']
    ['北京',102，103]
    ['上海',104，504]
]

#遍历
for row in lst:
    for item in row:
        print(item,end='\t')
    print()

#二维列表生成式
lst2=[[j for j in range(5)]for i in range(4)]#四行五列

3.元组

• 创建与删除

#使用()直接创建元组
元组名=（element1,element2,...,elementN）
#例子：
lst=('hello','world',98,[100,5])#('hello','world',98,[100,5])
#如果元组只有一个元素，逗号不能省，不然类型改变

#使用内置函数tuple()创建元组
元组名=tuple(序列)
#例子：
t=tuple('hello')#('h','e','l','l','o')
t=tuple([10,20,30])#将列表的元素作为元组的元素,(10,20,30)

#生成式
t=（expression for item in range if condition）
t=tuple(t)
print(t)

#删除元组
del 元组名

• 访问

print（t[0]）#通过索引

• 遍历

#使用for和元素
for item in t:
    print(item)

#使用for和索引
for i in range(0,len(t)):
    print(i,t[i])

#使用enumerate函数
for index,item in enumerate(t):
    print(index,item)

• 元组和列表的区别

元组	列表
不可变序列	可变序列
无法增删改	可以增删改
支持切片访问，不支持修改操作	支持切片访问和修改操作
访问和处理速度快	访问和处理速度慢
可以作为字典的键	不能作为字典的键

4.字典

• 是根据一个信息查找另一个信息，构成“键值对”，表示索引用的键和对应的值构成的成对关系，且键必须为不可变序列，键无序
• 创建与删除

#直接用{}
d={'cat':10,'dog':20}
print(d)

#用zip函数
lst1=['cat','dog']
lst2=[10,20]
z=zip(lst1,lst2)
d=dict(z)
print(d)

#使用dict
d=dict(cat=10,dog=20)
print(d)

#字典生成式
d={key:value for item in range}
d={key:value for key,value in zip(lst1,lst2)}

#元组可以作为键
t=(10,20,30)
print({t,10})


#删除
del 字典名

• 取值

d[key]
d.get(key)

#可以直接复制添加

• 遍历

#遍历出key与value的元组
for element in d.items():
      print(element)

#分别遍历出key和value
for key,value in d.items():
      print(key,value)

• 字典的其他操作

字典的方法	描述说明
d.keys()	获取所有key数据
d.values()	获取所有value数据
d.pop(key,default)	key存在获取相应的value，同时删除key-value对，否则获取默认值
d.popitem()	随机从字典中取出一个key-value对，结果为元组类型，同时将该key-value从字典中删除
d.clear()	清空字典中所有的key-value对
d1|d2	合并字典（3.11新特性）

5.集合

• 是一个无序的不重复元素序列，只能存储不可变数据类型（集合、字典和列表都是可变数据类型）
• 创建和删除

#直接使用{}
s={element1,element2,...,elementN}

#使用内置函数set()
s=set(可迭代对象)
#例子：
s=set('hello')#{'h','e','l','l','o'}
s=set([10,20,30])#{10,20,30}
s=set(range(1,10))

#集合生成式
s={expression for item in range}
s={expression for item in range if condition}

#删除
del 集合名

• 集合的遍历

for item in s:
    print(item)

for index,item in enumerate(s):
    print(index-->item)
#集合没有索引，index是序号

• 集合的操作符（和数学集合一样）

集合的操作符	描述说明
A&B	交集
A|B	并集
A-B	差集
A^B	补集

• 集合的其他操作方法

集合的方法	描述说明
s.add(x)	如果x不在集合s中则添加进去
s.remove(x)	如果x在集合s中则删除，不在则报错
s.clear	清除集合所有元素

五、字符串

1.字符串的查询操作

方法名称	描述说明
index()	查找子串第一次出现的位置，不存在则抛出异常
rindex()	查找子串最后一次出现的位置，不存在则抛出异常
find()	查找子串第一次出现的位置，不存在则返回-1
rfind()	查找子串最后一次出现的位置，不存在则返回-1

2.字符串的大小写转换操作

方法名称	描述说明
upper()	把字符串中所有字符串都转成大写字母
lower()	把字符串中所有字符都转成小写字母
swapcase()	把字符串中所有大写字母转成小写字母，所有小写字母都转成大写字母
capitalize()	把第一个字符转换为大写，把其余字符转换为小写
title()	把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换为小写

3.字符串内容对齐操作

方法名称	描述说明
center()	居中对齐，第一个参数指定宽度，第二个参数指定填充符（可不填，默认空格），如果指定宽度小于实际宽度返回字符串本身
ljust()	左对齐，两个参数同上
rjust()	右对齐，两个参数同上
zfill()	右对齐，左边用0填充，只接收指定宽度一个参数

4.字符串劈分操作

方法名称	描述说明
split()	从左边开始劈分，返回列表，可以通过sep指定劈分符（默认是空格），可以通过maxsplit指定劈分最大次数
rsplit()	从右边开始劈分，返回列表，可以通过sep指定劈分符（默认是空格），可以通过maxsplit指定劈分最大次数

5.判断字符串操作

方法名称	描述说明
isidentifier()	判断是否合法标识符
isspace()	判断是否空白字符组成（回车、换行
水平制表符）
isalpha()	判断是否全部字母组成
isdecimal()	判断是否全部十进制数字组成
isnumeric()	判断是否全部数字组成
isalnum()	判断是否全部字母和数字组成

6.其他操作

方法名称	描述说明
replace()	第一个参数指定被替换子串，第二个参数指定替换子串，第三个参数指定最大替换次数
join()	将列表或元组中的字符串合并成一个字符串
切片操作	产生新的字符串

7.格式化输出

# %占位符
print('我叫%s,今年%d岁' % (name,age))
#设置精度宽度同C语言

# {}占位符
print('我叫{0},今年{1}岁'.format(name,age))

# f-string
print(f'我叫{name},今年{age}岁')

六、函数

1.函数的创建

def 函数名(输入参数)
    函数体
    return xxx

2.函数的传递方式

def calc(a,b):

#位置实参
calc(10,20)

#关键字实参
calc(b=10,a=20)#可以任意顺序

3.函数的参数传递

• 对于不可变对象，不会改变实参值
• 对于可变对象，会改变（列表、字典等）

4.函数的返回值

• 如果函数没有返回值，return可以省略不写
• 如果函数返回值只有一个，直接返回类型
• 如果函数返回值有多个，返回结果为元组

5.函数的参数定义

• 默认值

def fun(a,b=10)
#给形参设置默认值，只有与默认值不符时才需要传递实参，只传一个参数b采用默认值

• 个数可变的位置形参

def fun(*args):
    print(args)
fun(10)
fun(10,20,30)
#结果为一个元组

• 个数可变的关键字形参

def fun(**args):
    print(args)
fun(a=10)
fun(a=10,b=20,c=30)
#结果为一个字典

• 两者都有时，要求个数可变的位置形参放在个数可变的关键字形参之前

6.序列和字典的传入

• 将序列传入函数要用*，把每个元素都转换为位置实参
• 将字典传入函数要用**，把每个键值对转换为欸关键字实参

7.局部变量和全局变量

• 全局变量：在函数外定义的变量
• 局部变量：函数内定义的变量，可以通过global在函数里定义为全局变量

七、Bug

1.异常类型

常见异常类型	描述
ZeroDivisionError	除（或取模）零（所有数据类型）
IndexError	序列中没有此索引
KeyError	映射中没有这个键
NameError	未声明/初始化对象（没有属性）
SyntaxError	Python语法错误
Value	传入无效的参数

2.程序调试

八、面向对象

1.定义

• 类：是多个类似事物组成的群体的统称，能够帮助我们快速理解和判断事物的性质
• 不同数据类型属于不同的类
• 对象：类之下包含的相似的不同个例，这个个例的专业术语称为实例或者对象（Python中一切皆对象）

2.类的创建

• 组成：类属性、初始化方法、实例方法、静态方法、类方法
• 模板：

class Student:
    #类属性：直接写在类里的变量
    native_pace='吉林'
   
    #初始化方法
    def __init__(self,name,age):
        self.name=name
        self.age=age
    
    #实例方法
    def eat(self)
        print('我要在括号里加上self')
    
    #静态方法
    @staticmethod
    def method():
        print('我使用了@staticmethod修饰')

    #类方法
    @classmethod
    def cm(cls):
        print('我要在括号里加上cls,且使用了@classmethod修饰')

3.对象的创建

• 对象的创建又称为类的实例化，有了实例就可以调用类中的类容
• 语法：实例名=类名（）
• 例子：

#创建Student类的对象
stu1=Student('张三',20)
print(stu1.name)
print(stu1.age)

#实例方法
stu1.eat()#对象名.方法名（）
Student.eat(stu1)#类名.方法名（类名）

4.类属性、类方法、静态方法

• 类属性：类中方法外的变量称为类属性，被该类的所有对象所共享

print(Student.native_place)#可以更改

• 类方法：使用@classmethod修饰的方法，使用类名直接访问的方法

Student.cm()

• 静态方法：使用@staticmethod修饰的方法，使用类名直接访问的方法

Student.sm()

5.动态绑定属性和方法

class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def eat(self)
        print(self.name+'在吃饭')

stu1=Student('张三',20)
stu1.gender='男'#给stu1动态绑定属性
print(stu1.gender)

def show():
    print('类外是函数，类里是方法')
stu1.show=show#给stu1动态绑定方法
stu1.show()

6.面向对象三特征：封装、继承、重写

• 封装的实现

class Student:
    def __init__(self,name,age):
        self.name=name
        self.__age=age
    def show(self)
        print(self.name,self.__age)

stu=Student('张三',20)
stu.show()
print(stu.name)
print(stu.__age)#报错，age被__修饰，不希望在类外使用
#但是可以通过dir(stu)函数强制找到

• 继承的实现

#一个类没有继承任何类则默认继承object
#Python支持多继承
#定义子类时，必须在其构造函数中调用父类的构造函数
#语法格式：class 子类名(父类1,父类2...):
class Person(object):#object可以不写
    def __init__(self,name,age):
        self.name=name
        self.__age=age
    def info(self):
        print('姓名：{0}，年龄：{1}'.format{self.name,self.age})

class Student(Person):
    def __init__(self,name,age,score):
        super().__init__(name,age)#使用super调用父类的构造函数
        self.score=score

stu=Student('Jack',20,'1001')
stu.info()

• 方法重写的实现

#如果子类对父类的某个属性或方法不满意，可以在子类中对其重写
#子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法
class Person(object):#object可以不写
    def __init__(self,name,age):
        self.name=name
        self.__age=age
    def info(self):
        print('姓名：{0}，年龄：{1}'.format{self.name,self.age})

class Student(Person):
    def __init__(self,name,age,score):
        super().__init__(name,age)#使用super调用父类的构造函数
        self.score=score
    def info(self):
        super().info()
        print('学号：{0}'.format(self.score))

stu=Student('Jack',20,'1001')
stu.info()

7.多态的实现

• 在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法
• 举例：

class Animal(object):
    def eat(self):
        print('动物要吃东西')
class Dog(Animal):
    def eat(self):
        print('狗吃肉')
class Cat(Animal):
    def eat(self):
        print('猫吃鱼')
class Person(object):
    def eat(self):
        print('人吃五谷杂粮')

def fun(animal)
    animal.eat()

fun(Dog())
fun(Cat())
fun(Person())

8.类的浅拷贝与深拷贝

• 变量的赋值操作：只是形成两个变量，实际上还是指向同一个对象

cpu1=CPU()
cpu2=cpu1
print(cpu1)
print(cpu2)

• 浅拷贝：Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象

computer=Computer(cpu1,disk)
import copy
computer2=copy.copy(computer)
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)

• 深拷贝：使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象与拷贝对象所有的子对象也不相同

computer=Computer(cpu1,disk)
import copy
computer3=copy.deeepcopy(computer)
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)

九、模块和包

1.模块的定义

• 一个.py的文件就是一个模块，一个模块可以包含N多个函数、类（包含方法、类属性等）、语句
• 一个程序包含N多个包，一个包包含N多个模块
• 方便其他程序和脚本的导入并使用，避免函数名和变量名的冲突。模块化编程，有利于团队开发（分别开发+反复调用）

2.导入模块

• 使用定义好的模块
• 模板：

import 模块名称#和java相似
from 模块名称 import 函数/变量/类

#如果是自定义的模块，要先找到Mark Directory as Sources Root点击

3.以主程序运行

if _name_ = '_main_':(main+回车可以快速打印)
    语句块
#意思是：只有点击运行该.py文件，即将该文件以主程序运行时才会运行if _name_ = '_main_':下的语句块

4.包的定义

• 包是一个分层次的目录结构，它将一组功能相近二等模块组织在一个目录下
• 避免模块名称冲突
• 包含__init__.py文件的目录（Directory）称为包（Python Package）

5.包的导入

• 模板：

import 包名.模块名

6.常用的内置模块

模块名	描述
sys	与Python解释器及其坏境操作相关的标准库
time	提供与时间相关的各种函数的标准库
os	提供了访问操作系统服务功能的标准库
calendar	提供与日期相关的各种函数的标准库
urllib	用于读取来自网上（服务器）的数据标准库
json	用于使用JSON序列化和反序列化对象
re	用于在字符串中执行正则表达式匹配和替换
math	提供标准算数运算函数的标准库
decimal	用于进行精确控制运算精度、有效数位和四舍五入操作的十进制运算
logging	提供了灵活的记录事件、错误、警告和调试信息等日志信息的功能

7.第三方模块安装

• 在线安装方式：

window+r弹出运行命令
输入cmd弹出控制台
输入  pip install 模块名  进行安装
输入  import 模块名  检查是否安装成功

十、文件操作

1.文件的打开

file = open(filename,mode,encoding)
#filename要创建或打开的文件名称
#mode打开模式默认为只读
#默认文本文件中字符的编写格式为gbk

2.打开模式

打开模式	描述
r	只读模式
w	只写模式，不存在则创建，覆盖原有内容
a	追加模式，不存在则创建，存在则在文件末尾追加内容
b	二进制方式打开文件，rb/wb
+	读写方式打开文件，a+等

3.文件对象的常用方法

方法名	说明
read(size)	从文件中读取size个字节或字符的内容返回，省略size则读取到文件末尾
readline()	从文本文件中读取一行内容
readlines()	从文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回
write(str)	将字符串str内容写入文件
writelines(s_list)	将字符串列表s_list写入文本文件，不添加换行符
seek(offset,whence)	移动文件指针位置，offset表示相对位置，whence取值0、1、2
tell()	返回文件指针的当前位置
flush()	把缓冲区的内容写入文件，但不关闭文件
close()	把缓冲区的内容写入文件，且关闭文件，释放文件对象相关资源

4.with语句（上下文管理器）

with open(filename,mode,encoding) as 别名
    语句块
#不用写close()，不论什么原因跳出with，都能保证文件正确关闭，释放资源