Python基础知识
Python入门
1.注释的分类
单⾏：# 注释内容 ，快捷键ctrl+/
多⾏： """ 注释内容 """ 或 ''' 注释内容 '''
2.定义变量：
变量名 = 值
标识符：数字、字⺟、下划线组成 不能数字开头 不能使⽤内置关键字 严格区分⼤⼩写
3.bug工具：
打断点，调试
4.数据类型 ：
整型：int 浮点型：float 字符串：str 布尔型：bool 元组：tuple 集合：set 字典：dict
5.格式化输出：
%s 字符串 %d 有符号的⼗进制整数 %f 浮点数 %c 字符 %u ⽆符号⼗进制整数 %o ⼋进制整数 %x ⼗六进制整数（⼩写ox） %X ⼗六进制整数（⼤写OX） %e 科学计数法（⼩写'e'） %E 科学计数法（⼤写'E'） %g %f和%e的简写 %G %f和%E的简写
6.输入
input('提示⽂字')
7.类型转换：
int(x [,base ]) 将x转换为⼀个整数
float(x ) 将x转换为⼀个浮点数 complex(real [,imag ]) 创建⼀个复数，
real为实部，imag为虚部
str(x ) 将对象 x 转换为字符串
repr( x ) 将对象x转换为表达式字符串 eval(str ) ⽤来计算在字符串中的有效Python表达式,并返回⼀个对象
tuple(s ) 将序列 s 转换为⼀个元组
list(s ) 将序列 s 转换为⼀个列表
chr(x ) 将⼀个整数转换为⼀个
Unicode字符 ord(x ) 将⼀个字符转换为它的ASCII整数值
hex(x ) 将⼀个整数转换为⼀个⼗六进制字符oct(x ) 将⼀个整数转换为⼀个⼋进制字符串 bin(x ) 将⼀个整数转换为⼀个⼆进制字符串
8.运算符
8.1算数运算符：+ - * / // % ** （）
混合运算优先级顺序：() ⾼于**⾼于* / // % ⾼于 + -
8.2 赋值运算符：= 赋值
复合赋值运算符：】算术运算符+赋值符+=，-=，*=，/=，//=，%=，**=
8.3比较运算符：==判断值相等
！=不等 > < <= >=
8 .4逻辑运算符：and or not
流程控制语句
1.if 条件:
条件成⽴执⾏的代码1
条件成⽴执⾏的代码2
......
2 .if 条件:
条件成⽴执⾏的代码1
条件成⽴执⾏的代码
......
else:
条件不成⽴执⾏的代码1
条件不成⽴执⾏的代码2
......
3.i f 条件1:
条件1成⽴执⾏的代码1
条件1成⽴执⾏的代码2
......
elif 条件2：
条件2成⽴执⾏的代码1
条件2成⽴执⾏的代码2
...... ......
else:
以上条件都不成⽴执⾏执⾏的代码
4.嵌套
if 条件1：
条件1成⽴执⾏的代码
条件1成⽴执⾏的代码
if 条件2：
条件2成⽴执⾏的代码
条件2成⽴执⾏的代码
循环
1. while 条件:
条件成⽴重复执⾏的代码1
条件成⽴重复执⾏的代码2
2. break终止循环
continue退出当前循环，进入下一次
3.嵌套
while 条件1:
条件1成⽴执⾏的代码
......
while 条件2:
条件2成⽴⾏的代码
......
4.for循环
for 临时变量 in 序列:
重复执⾏的代码1
重复执⾏的代码2
......
5. while 条件:
条件成⽴重复执⾏的代码
else:
循环正常结束之后要执⾏的代码
6. for 临时变量 in 序列:
重复执⾏的代码
...
else:
循环正常结束之后要执⾏的代码
数据序列
1.字符串
一对引号的字符串
数据类型：str
三引号的字符串支持换行，在Python中，使⽤ input() 接收⽤户输⼊。“下标” ⼜叫 “索引” ，就是编号
切片：序列[开始位置下标:结束位置下标:步⻓]
查找：字符串序列.find(⼦串, 开始位置下标, 结束位置下标)
ndex()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则 报异常。
rfind()： 和find()功能相同，但查找⽅向为右侧开始。
rindex()：和index()功能相同，但查找⽅向为右侧开始。
count()：返回某个⼦串在字符串中出现的次数
修改：替换：序列.replace(旧⼦串, 新⼦串, 替换次数)
分割：字符串序列.split(分割字符, num)
连接：字符或⼦串.join(多字符串组成的序列)
cipitalize()将字符串第⼀个字符转换成⼤写。
title()：将字符串每个单词⾸字⺟转换成⼤写。
ower()：将字符串中⼤写转⼩写
upper()：将字符串中⼩写转⼤写
strip()：删除字符串左侧空⽩字符。
rstrip()：删除字符串右侧空⽩字符。
strip()：删除字符串两侧空⽩字符。
ljust()：返回⼀个原字符串左对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串
字符串序列.ljust(⻓度, 填充字符)
rjust()：返回⼀个原字符串右对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语法和 ljust()相同。
center()：返回⼀个原字符串居中对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语 法和ljust()相同。
判断：startswith()检查字符串是否是以指定⼦串开头
语法：字符串序列.startswith(⼦串, 开始位置下标, 结束位置下标)
endswith()：：检查字符串是否是以指定⼦串结尾，
语法：字符串序列.endswith(⼦串, 开始位置下标,结束位置下标)
isalpha()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟
sdigit()：如果字符串只包含数字则
salnum()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟或数字
sspace()：如果字符串中只包含空⽩
2.列表：
格式：[数据1, 数据2, 数据3, 数据4......]
查找：index()：返回指定数据所在位置的下标
语法：列表序列.index(数据, 开始位置下标, 结束位置下标)
count()：统计指定数据在当前列表中出现的次数
len()：访问列表⻓度，即列表中数据的个数。
in：判断指定数据在某个列表序列，
not in：判断指定数据不在某个列表序列
增加：append()：列表结尾追加数据。
语法：列表序列.append(数据)
extend()：列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表
语法：列表序列.extend(数据)
insert()：指定位置新增数据
语法：列表序列.insert(位置下标, 数据)
删除：del 目标
Pop()：删除指定下标的数据(默认为最后⼀个)，并返回该数
语法：列表序列.pop(下标)
remove()：移除列表中某个数据的第⼀个匹配项。
语法：列表序列.remove(数据)
clear()：清空列表
修改：修改指定下标：name_list[0] = 'aaa'
逆置：列表.reverse()
排序：列表.sort( key=None, reverse=False)
注意：reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）
复制：name_li2 = name_list.copy()
遍历：while遍历：
while i < len(name_list):
print(name_list[i])
i += 1
for遍历：
for i in name_list:
print(i)
列表嵌套：name_list = [['⼩明', '⼩红', '⼩绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']
3.元组
⼀个元组可以存储多个数据，元组内的数据
是不能修改的
定义：定义元组使⽤⼩括号，且逗号隔开各个数
据，数据可以是不同的数据类型
元组的常⻅操作：
按下标查找数据
index( )：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index ⽅法相同。
count( )：统计某个数据在当前元组出现的次数
len( )：统计元组中数据的个数。
注意：元组内的直接数据如果修改则⽴即报错
但是如果元组⾥⾯有列表，修改列表⾥⾯的数据则是⽀持的，故⾃觉很重要
如果定义的元组只有⼀个数据，那么这个数据后⾯也好添加逗号，
4.字典
创建字典：符号为⼤括号 数据为键值对形式出现 各个键值对之间⽤逗号隔开
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
注意：字典为可变类型。
常⻅操作：
增：字典序列[key] = 值
删: del( ) / del：删除字典或删除字典中指定键值
clear( )：清空字典
改：字典序列[key] = 值
查：key值查找：print(dict1['name'])
如果当前查找的key存在，则返回对应的值；否则则报错。
get( )：字典序列.get(key, 默认值)
如果当前查找的key不存在则返回第⼆个参数(默认值)，如果省略第⼆个参数，则返回 None
keys()：print(dict1.keys())全部键
values() : print(dict1.values())全部值
items()：print(dict1.items())全部键值对
遍历：
遍历字典的key
for key in dict1.keys():
print(key)
遍历字典的value
for value in dict1.values( ):
print(value)
遍历字典的元素
for item in dict1.items( ):
print(item)
遍历字典的键值对
for key, value in dict1.items( ):
print(f'{key} = {value}')
5.集合
创建集合使⽤ { } 或 set( ) ， 但是如果要创建空集合只能使⽤ set( ) 因为{ } ⽤来创建空典。
1. 集合可以去掉重复数据；
2. 集合数据是⽆序的，故不⽀持下标
增：add( )
update(), 追加的数据是序列
删: remove()，删除集合中的指定数据，如果数据不存在则报错
discard()，删除集合中的指定数据，如果数据不存在也不会报错
pop()，随机删除集合中的某个数据，并返回这个数据。
查: in：判断数据在集合序列
not in：判断数据不在集合序列
6.公共操作：
1.运算符：
| 运算符 | 描述 | 支持类型 |
| + | 合并 | 字符串，列表，元组 |
| * | 复制 | 字符串，列表，元组 |
| In | 元素是否存在 | 字符串，列表，元组，字典 |
| Not in | 元素是否存在 | 字符串，列表，元组，字典 |
2.公共方法：
| 函数 | 描述 |
| Len（） | 计算容器中元素个数 |
| del del() | 删除 |
| max() | 返回容器中最大值 |
| min() | 返回容器中最小值 |
| range(start, end,step) | ⽣成从start到end的数字，步⻓为 step，供for循环使⽤ |
| enumerate() enumerate(可遍历对象, start=0) | 函数⽤于将⼀个可遍历的数据对象组合为⼀个索引序 列，同时列出数据和数据下标，⼀般⽤在 for 循环当中。Start设置起始值 |
3.类型转换
tuple( ) 作⽤：将某个序列转换成元组
list( ) 作⽤：将某个序列转换成列表
set( ) 作⽤：将某个序列转换成集合
7.推导式
1.列表推导式：
作⽤：⽤⼀个表达式创建⼀个有规律的列表或
制⼀个有规律列表列表推导式
list1 = [i for i in range(10)]
list1 = [i for i in range(10) if i % 2 == 0]
list1 = [(i, j) for i in range(1, 3) for j in range(3)]
2.字典推导式：
dict1 = {i: i**2 for i in range(1, 5)}
将两个列表合并为⼀个字典
dict1 = {list1[i]: list2[i] for i in range(len(list1))}
提取字典中⽬标数据
count1={key:valuefor key, value in counts.items() if value >= 200}
3.集合推导式
set1 = {i ** 2 for i in list1}
函数
函数的参数
函数调⽤的时候可以传⼊真实数据，增⼤函数的使⽤的灵活性
形参：函数定义时书写的参数(⾮真实数据)
实参：函数调⽤时书写的参数(真实数据)
函数的作⽤：封装代码，⾼效的代码重⽤
1.使用步骤
1.1定义函数
def 函数名(参数):
代码1
代码2
.......
1.2调用函数
函数名(参数)
2.返回值:
def buy():
return '烟'
3.语法
def 函数名(参数):
""" 说明⽂档的位置 """
代码
......
4. 嵌套调⽤
所谓函数嵌套调⽤指的是⼀个函数⾥⾯⼜调⽤了另外⼀个函数。如果函数A中，调⽤了另外⼀个函数B，那么先把函数B中的任务都执⾏完毕之后才会回到上 次 函数A执⾏的位置。
5.变量作⽤域
变量作⽤域指的是变量⽣效的范
围主要分为两类：局部变量和全局变量
局部变量 :所谓局部变量是定义在函数体内部的变量，即只在函数体内部⽣效
作⽤:在函数体内部，临时保存数据，即当函数调⽤完成后，则销毁局部变量
全局变量: 所谓全局变量，指的是在函数体内、外都能⽣效的变量
6. 函数的返回值
1.return a, b 写法，返回多个数据的时候，默认是元组类型。
2. return后⾯可以连接列表、元组或字典，以返回多个值。
7. 函数的参数
位置参数：调⽤函数时根据函数定义的参数位置来传递参数。
关键字参数: 函数调⽤，通过“键=值”形式加以指定。可以让函数更加清晰、容易使⽤，同时也清除了参数的顺序需 求。
缺省参数: 缺省参数也叫默认参数，⽤于定义函数，为参数提供默认值
不定⻓参数: 不定⻓参数也叫可变参数。⽤于不确定调⽤的时候会传递多少个参数(不传参也可以)的场景。包裹位置传递(*args)
包裹关键字传递(**kwargs)
8. 可变和不可变类型
可变类型： 列表 字典 集合
不可变类型 ：整型 浮点型 字符串 元组
文件操作
⽂件操作的作⽤就是把⼀些内容(数据)存储存放起来，可以让程序下⼀次执⾏的时候直接使 ⽤，⽽不必重新制作⼀份，省时省⼒
1.⽂件的基本操作
打开：open(name, mode)
name：是要打开的⽬标⽂件名的字符串(可以包含⽂件所在的具体路径)。
mode：设置打开⽂件的模式(访问模式)：只读、写⼊、追加等
打开⽂件模式:
2.⽂件对象⽅法
写: 对象对象.write('内容')
读：⽂件对象.read(num) num表示要从⽂件中读取的数据的⻓度（单位是字节），如果没有传⼊num，那么就表示读取⽂ 件中所有的数据
readlines() 可以按照⾏的⽅式把整个⽂件中的内容进⾏⼀次性读取，并且返回的是⼀个列表，其中每⼀⾏ 的数据为⼀个元素
readline( ) ⼀次读取⼀⾏内容
seek() 作⽤：⽤来移动⽂件指针。 语法如下: ⽂件对象.seek(偏移量, 起始位置)
起始位置:0⽂件开头1当前位置 2⽂件结尾
关闭：⽂件对象.close()
3. ⽂件和⽂件夹的操作
导⼊os模块 import os
使⽤ os 模块相关功能 os.函数名()
⽂件重命名 : os.rename(⽬标⽂件名, 新⽂件名)
删除⽂件: os.remove(目标文件名)
创建文件夹： os.mkdir(⽂件夹名字)
删除文件夹：os.rmdir(文件夹名字)
获取当前文件夹：os.getcwd()
改变默认目录：os.chdir(目录)
获取默认目录列表：os.listdir(目录)
面对对象
1.面向对象基础
⾯向对象就是将编程当成是⼀个事物，对外界来说，事物是直接使⽤的，不⽤去管他内部 的情况。⽽编程就是设置事物能够做什么事。在⾯向对象编程过程中，有两个重要组成部分：类 和 对象。类和对象的关系：⽤类去创建⼀个对象
类是对⼀系列具有相同特征和⾏为的事物的统称，是⼀个抽象的概念，不是真实存在的事物。 特征即是属性 ⾏为即是⽅法 类⽐如是制造洗⾐机时要⽤到的图纸，也就是说类是⽤来创建对象。
1.类和对象：
定义类： class 类名():
代码 ......
注意：类名要满⾜标识符命名规则，同时遵循⼤驼峰命名习惯。
创建对象: 对象名 = 类名()
self指的是调⽤该函数的对象。
2. 添加和获取对象属性
类外⾯添加对象属性 对象名.属性名 = 值
类外⾯获取对象属性 对象名.属性名
类⾥⾯获取对象属性： self.属性名
3. 魔法⽅法
在Python中， __xx__() 的函数叫做魔法⽅法，指的是具有特殊功能的函数。.
__init__( )： ⽅法的作⽤：初始化对象。
在创建⼀个对象时默认被调⽤，不需要⼿动调⽤ __init__(self) 中的self参数，不需要开发者传递，python解释器会⾃动把当前的对象引 ⽤传递过去
带参数: __init__(self, width, height):
self.width = width
self.height = height
__str__( ): 当使⽤print输出对象的时候，默认打印对象的内存地址。如果类定义了__str__ ⽅法，那么就会打印从 在这个⽅法中 return 的数据。
__del__( ): 当删除对象时，python解释器也会默认调⽤ __del__( ) ⽅法
2.面向对象——继承：
经典类或旧式类
在Python中，所有类默认继承object类，object
类是顶级类或基类；其他⼦类叫做派⽣类
不由任意内置类型派⽣出的类，称之为经典类。
class 类名:
代码 ......
新式类：class 类名(object):
代码.........
单继承：子类继承一个父类
class Prentice(Master):
pass
多继承：所谓多继承意思就是⼀个类同时继承了多个⽗类 class Prentice(School, Master):
Pass
⼦类重写⽗类同名⽅法和属性:⼦类和⽗类具有同名属性和⽅法，默认⽤⼦类属性和⽅法
FoodParent.__init__(self) 绑定父类构造方法
⼦类调⽤⽗类的同名⽅法和属性:
多层继承:
super()调⽤⽗类⽅法：super().__init__() super().make_cake()
多用于多继承
私有权限：在Python中，可以为实例属性和⽅法设置私有权限，即设置某个实例属性或实例⽅法不继承给⼦类。
设置私有权限的⽅法：在属性名和⽅法名 前⾯ 加上两个下划线 _ _
self.__money = 2000000
def __info_print(self):
⭐私有属性和私有⽅法只能在类⾥⾯访问和修改
获取和修改私有属性值：在Python中，⼀般定义函数名 get_xx ⽤来获取私有属性，定义set_xx ⽤来修改私有属性值
3.面对对象-其他
⾯向对象三⼤特性：
封装：将属性和⽅法书写到类的⾥⾯的操作即为封装 封装可以为属性和⽅法添加私有权限
继承：⼦类默认继承⽗类的所有属性和⽅法 ⼦类可以重写⽗类属性和⽅法
多态：多态是⼀种使⽤对象的⽅式，⼦类重写⽗类⽅法，调⽤不同⼦类对象的相同⽗类⽅法，可以 产⽣不同的执⾏结果
传⼊不同的对象，产⽣不同的结果
实现步骤：定义⽗类，并提供公共⽅法
定义⼦类，并重写⽗类⽅法
传递⼦类对象给调⽤者，可以看到不同⼦类执⾏效果不同
类属性和实例属性：类属性就是 类对象 所拥有的属性，它被 该类的所有实例对象 所共有。 类属性可以使⽤ 类对象 或 实例对象 访问。
class Dog(object):
tooth = 10
print(Dog.tooth)
实例属性 要求 每个对象 为其 单独开辟⼀份内存空间 来记录数据，⽽ 类属性 为全类所共有 仅占⽤⼀份内存，更加节省内存空间。
修改类属性：Dog.tooth=12 wangcai.tooth= 20
类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了 ⼀个实例属性
类⽅法和静态⽅法:
类⽅法: 需要⽤装饰器 @classmethod 来标识其为类⽅法.对于类⽅法，第⼀个参数必须是类对象，⼀般以 cls作为第⼀个参数。
当⽅法中需要使⽤类对象(如访问私有类属性等时，定义类⽅法 类⽅法⼀般和类属性配合使⽤
静态⽅法: 需要通过装饰器 @staticmethod 来进⾏修饰，静态⽅法既不需要传递类对象也不需要传递实例对象 （形参没有self/cls）
静态⽅法 也能够通过 实例对象和类对象去访问
静态⽅法使⽤场景: 当⽅法中既不需要使⽤实例对象也不需要使⽤类对象时，静态⽅法既可以使⽤对象访问⼜可以使⽤类访问
模块-包-异常
1. 异常
语法: try:
可能发⽣错误的代码
except:
如果出现异常执⾏的代码
捕获指定异常: try:
可能发⽣错误的代码
except 异常类型:
捕获到该异常类型执⾏的代码
捕获异常描述信息:
try:
print(num)
except (NameError, ZeroDivisionError) as result: print(result)
捕获所有异常:except Exception as result:
异常的else: try:
print(1)
except Exception as result: print(result)
else: print(没有异常的时候执⾏)
异常的finally:
finally表示的是⽆论是否异常都要执⾏的代码
try:
f = open('test.txt', 'r')
except Exception as result:
f = open('test.txt', 'w')
else:
print('没有异常，真开⼼')
finally:
f.close()
⾃定义异常:
⾃定义异常的语法raise异常类对象
# 1. ⾃定义异常类
class 异常类类名(Exception):
代码
# 设置抛出异常的描述信息
def __str__(self):
return ...
# 2. 抛出异常
raise 异常类名()
# 捕获异常
except Exception...
2.模块和包
模块：Python 模块(Module)，是⼀个 Python ⽂件，以 .py 结尾，包含了 Python 对象定义和Python语句。 模块能定义函数，类和变量，模块⾥也能包含可执⾏的代码。
导⼊模块：import 模块名
import 模块名1, 模块名2...
from 模块名 import 功能1，...
from 模块名 import *
import 模块名 as 别名
from 模块名 import 功能名 as 别名
调用模块：块名.功能名()
制作模块: 新建⼀个Python⽂件，命名为my_module1.py 并定义 testA函数。
调⽤模块：import my_module1
__all__：__all__ = ['testA']
如果⼀个模块⽂件中有 __all__ 变量，当使⽤ from
xxx import * 导⼊时，只能导⼊这个列表中的元素
包： 包将有联系的模块组织在⼀起，即放到同⼀
个⽂件夹下，并且在这个⽂件夹创建⼀个名字 为
__init__.py ⽂件，那么这个⽂件夹就称之为包。
注意：新建包后，包内部会⾃动创建 __init__.py ⽂件，这个⽂件控制着包的导⼊⾏为
导⼊包：import 包名.模块名
包名.模块名.⽬标
from 包名 import * 模块名.⽬标
注意：必须在 __init__.py⽂件中添加__all__= [ ] ，控制允许导⼊的模块列表。
