Python基础知识学习

快捷键

• ctrl + d ：快速复制粘贴一行
• shift + enter ： 快速新建一行
• ctrl + alt + l ：快速格式化

数据类型分类

数字型

• 整型：int
• 浮点型：float
• 布尔型：bool

非数字型

• 字符串：使用引号引起来的就是字符串
• 列表：list[]
• 元组：tuple()
• 集合：set{}
• 字典{" “:” "}

获取变量的数据类型，使用type(变量)函数，使用print来打印输出变量的数据类型
eg：print(type(age))

数据类型转换

int：整数

将变量转换为一个整数

变量必须是整数类型的字符串

float：浮点数

将变量转换为一个浮点数

变量是数字类型字符串即可

str：字符串

将变量转换为一个字符串

任意数据类型都可转换为字符串类型

1、转义字符 \n \t \' \''

原生字符串 ：在字符串的前边，加上r" "，字符串中 的 \ 就不会进行转义了

2、字符串查找

格式：字符串.find（输入查找的内容）

返回值：
1、如果存在，返回第一次出现查找内容的位置的下标
2、如果不存在查找的内容，则返回 - 1

3、字符串替换

格式：字符串.replace（输入被替换的内容，输入替换的内容，count）

count：表示全部内容替换，可指定替换的次数
返回：返回一个替换后的完整的字符串

注意：原字符串不会被改变

4、字符串的分割

格式：字符串.split（'sep'）

将字符串按照指定的字符串 sep 进行分割
sep ：按照 sep 进行分割，可以不写，默认按照空白字符（空格 \t \n）分割

返回：列表，列表中的每个数据就是分割后的字符串

5、字符串的连接

格式：'字符串'.join（容器)

容器一般是列表，将字符串插入到列表相邻的两个数据之间，组成新的字符串

注意：列表中的数据 必须都是字符串才可以

tuple：元组

将序列变量转换为一个元组

1、元组使用（）
2、元组中的数据不能修改，列表中的数据可以修改
3、元组只有查询方法，如index、count，支持下标和切片，主要用户传参和返回值

定义只有一个数据的元组，数据后必须有一个逗号
eg：test = （15,）

元组的特殊用法：交换两个变量的值

①组包（pack）：将多个数据值组成元组的过程 eg ：a = 1；b = 5；c = a，b
②拆包（unpack）：将容器中多个数据，分别给到多个变量 eg ： c = （5，2）；a，b = c
③交换变量 eg ： a = 4；b = 5；a，b = b，a

list：列表

将序列变量转换为一个列表

1、列表查询

格式：列表.index（数据值）

index()：和字符串的 find()的作用一样

查询成功，返回下标，否则直接报错

2、列表统计

格式：列表.count（指定的要统计的数据）

统计 指定数据在列表中出现的次数

3、列表 数据 添加

格式：列表 . append（输入要添加的数据）

在列表的尾部添加数据

返回：None，所有不使用变量 = 列表.append()直接在列表中添加数据，不会生成新的列表，如果要查看添加后的数据，直接print()输出打印原列表

4、列表 数据 删除

格式：列表.pop（要删除的数据的下标）

根据列表的下标删除列表中的数据 下标不写默认删除最后一个

5、列表的反转

格式：
①字符串[：：-1 ] ：得到一个新的列表，原列表不会改动
②列表.reverse ：直接修改原列表的数据

6、列表的排序

前提：列表的数据类型要一样

格式：列表.sort()
升序、从小到大，直接在原列表中进行排序

列表.sort（reverse = True）：表示降序

7、列表的长度

格式：len(列表)

dict：字典

使用 { } 表示
字典是由键（key）值（value）对组成的
①key：value，一个键值对是一组数据，多个键值对之间用 逗号（，）隔开
②字典的键不能重复
③字典中的键主要使用 字符串 类型

1、字典的增加和修改

格式：字典['键'] = 值
①如果键存在，则进行修改
②如果键不存在，则进行增加，增加在字典末尾

2、字典的删除

根据字典的 键 删除键值对

格式：字典.pop('键')

3、字典的查询

根据字典的 键 ，获取对应的键值对

格式：
①字典['键']：如果 键 不存在，则会报错
②字典.get(键)：如果 键 不存在，则返回 None

4、字典的遍历

• 遍历字典的键

格式①：

for 变量 in 字典：
  print(变量)

格式②：

for 变量 in 字典.keys()：
  print(变量)

• 遍历字典的值

格式：

for 变量 in 字典.values()：
  print(变量)

• 变量字典的键和值

格式：

for 变量1,变量2 in 字典.items()：
  print(变量1,变量2)

注：变量1获取的是键，变量2获取的是值

set：集合

使用 { 数据1，数据2，数据3 } 表示

①集合中的数据不能重复，没有重复的数据
②对列表进行去重操作，可以将列表转换为集合，再将集合转换为列表进行去重

格式化输出

格式①：字符串.format

字符串中需要使用变量的地方，使用{}进行占位
在format的括号中按照占位的顺序，将变量写上去

eg：print(‘我的名字是 {}，年龄 {} 岁，性别为 {} 。’ . format(name,age,sex))

格式②：F - string

在字符串前边加上 f ‘‘或者 F’’
字符串中需要使用变量的位置，使用 {} 进行占位
将变量直接写在占位的大括号里

eg：print(‘我的名字是 {name},年龄 {age} 岁,性别为 {sex} 。’)

转义字符

\n ：表示换行，回车
\t ：表示制表符，tab键

运算符

算术运算符

• // ：表示求商，获取的是两个数据做除法的商
• % ：表示取余，获取的是两个数据做除法的余数
• ** ：幂，次方

优先级：** * / // % + -

比较运算符

• ！=：不相等
• >=：大于等于
• <=：小于等于

赋值运算符

• = ：赋值，a=5，将5赋值给变量a
• += ：加后赋值，a+=b，将 a+b 的值给 a，相当于 a = a +b
• -= ：减后赋值，a-=b，将a-b的值给a，相当于a = a-b
• *= ：乘后赋值
• /= ：除后赋值
• %= ：取余后赋值，将a/b的余数给a

逻辑运算符

• and ：逻辑与，并且
• or ：逻辑或，或者
• not ：逻辑非，取反

流程控制

判断（如果…否则…）：if（如果），elif（如果），else（否则）

循环：while（直到），for in （在），break（终止），continue（继续）

pass ：空语句，可以进行占位

while 判断条件

判断条件成立执行的代码
判断条件成立执行的代码

for 循环

for 变量 in 字符串：
  重复执行的代码

for 变量 in range(n)：  #n表示循环的次数
  重复执行的代码

range（n）可以生成[0，n）的整数的序列，不包含n

break

当程序代码执行遇到break，break所在的循环就会被终止执行

continue

当程序代码执行遇到continue，continue后续的代码不执行，但是会继续下一次的循环（结束本次循环，继续下一次的循环）

debug调试代码

目的：查看代码的执行过程

想要查看代码的执行过程，建议将断点放在第一行，在代码和行号之间 点击出现的红色圆点 就是断点，再次点击可以取消断点

pycharm想要debug运行，至少需要两个断点才可debug成功

下标（索引）

下标是数据在容器（字符串、列表、元组）中的位置编号，使用的是正数下标，从 0 开始，也支持负数下标， - 1 表示最后一个位置的数据

切片

使用切片操作，可以一次性获取容器中的多个数据（多个数据之间的一定的规律，数据的下标是
等差数列（相邻的两个数字之间的差值是一样的））

语法： 容器名[start:end:step]
1、start：表示开始位置的下标
2、end ：表示结束位置的下标，但是 end 所对应的下标位置的数据是不能取到的
3、step：步长，表示的意思是相邻两个位置的差值，即等差数列的 差

函数

函数是把具有独立功能的代码块组织为一个小模块，在需要的时候调用，减少代码 的冗余

定义格式

def 函数名()：
   函数中的代码

调用格式

函数名()

函数的查看

①在函数名上，使用快捷键 ctrl + q 查看
②在函数名上，使用快捷键 ctrl + b 跳转到函数定义的地方查看
③在函数名上，按住 ctrl 键，点击函数名，跳转到函数定义的地方查看

return 关键字的作用

①将一个数据值返回到调用的地址，函数遇到 return 会结束函数的执行
②return 关键字只能用在函数中
③如果一个函数没有写 return ，可以认为返回的是 None

模块的导入的方法

①import 模块名
模块名 就是代码文件名，去掉 . py 即可，此功能多用于导入系统中的常用的模块和功能

使用模块中的功能：
模块名.功能名
功能可以是变量、函数或者类

②from 模块名 import 功能名
导入指定的功能，此功能多用于导入自己书写的，或第三方

使用模块名中的功能:
功能名()

__name__变量的作用

if __name__ == '__main__'
在被导入文件中这个 if 的缩进中书写的代码，导入的时候不会被执行

1、在模块中，直接右键运行代码文件，__name__变量的值是 “__main__”
2、如果是在被导入运行代码文件，__name__变量的值是 模块名（文件名）

模块导入顺序

1、在导入模块的时候，会先从代码所在的目录进行导入
2、如果没有找到，会去python系统的目录朝招导入
3、如果没有找到，会进行报错

注：自定义的代码文件名字，不要和导入的系统的模块文件名一样

包的导入

方法一：import 包名.模块名
使用：包名 . 模块名 . 工具名

方法二：from 包名 import 模块名
使用：模块名.工具名

方法三：from 包名 . 模块名 import 工具名
使用：工具名

方法四：
直接输入工具名，然后使用快捷键 alt + enter

引用

引用是变量中保存数据的地址

python 中所有数据的传递，传递的都是引用（即地址）
赋值运算符（=），会改变变量的引用，即只有 = 可以修改变量的引用
可以使用 id （变量） 函数，查看变量的引用

匿名函数

使用 lamdba 关键字 定义的表达式称为匿名函数

格式： lamdba 参数,参数：一行代码

作用：
①只能实现简单的功能，只能写一行代码
②一般不直接调用，作为函数 的参数使用的

面向对象

定义：一种编程方法，编程思想，是一种用于解决业务问题的思路、方式

三大特性：
①封装：根据需求将属性和方法封装到一个抽象的类中
②继承：实现代码的重用，相同的代码不需要反复的编写
③多态：不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度

类

对具有相同特征或者行为的事物的一个统称，抽象的，不能直接使用。指代 多个事物，即拥有一定的整体特征。代码中类是由关键字 class 定义的

类的三要素

①类名：同类事物的命名，所有单词的首字母都要大写
②属性：事物的特征
③方法：事物的行为

面向对象的步骤

①设计类（找类的三要素）
②定义类
③创建对象（实例化对象）
④由对象调用类中的方法

定义类

class 类名  ：
  #在class的缩进中定义类的属性和方法
  def 方法名（self）： #方法的本质是函数

创建对象

对象是由类创建的
类名（）：创建的对象的格式
一般使用变量将创建的对象保存起来

变量 = 类名 #一般将这个变量 称为对象，其本质就是变量中保存的是对象的引用地址

调用类中的方法

由类创建的对象，调用类中的方法

对象.方法名()#调用类的方法

对象

由类创建出来的一个具体存在的事物，可以直接使用 。指代 一个具体事物。即有具体的实现的。代码中 使用 类 去创建（实例化）

属性

属性表示事物的特征
可以给对象添加属性，或者获取对象的属性值

①给对象添加属性方法：
对象 . 属性名 = 属性值 #添加或者修改属性
②获取对象的属性值方法： 对象.属性名
③在方法中操作属性（self 是的对象）方法：
self.属性名 = 属性值 self.属性名

魔法方法

在 python 中存在的一类方法，以两个下划线开头，两个下划线结尾，在满足某个条件的情况下，自动调用，这一类方法 称为是魔法方法

初始化方法：_ _init_ _

①调用的时机：在创建的对象后，自动调用
②应用场景：初始化对象，给对象添加属性
③注意事项：如果属性是变化的，则可以将这个属性的值作为参数传递，在创建对象的时候，必须传递实参值

_ _str_ _方法

①调用时机：使用print（对象）打印对象的时候，自动调用
如果没有定义 _ _str_ _方法，默认打印的是 对象的引用地址
如果定义了_ _str_ _方法，打印的是 方法的返回值
②应用场景：使用print（对象）打印输出对象的属性信息
③注意事项：必须返回一个 字符串

继承

继承描述的是类与类之间的关系 is 。。。。。a
继承的好处：减少代码的冗余，重复代码不需要多次书写，提高编程效率，子类对象可以直接使用父类中的属性和方法

语法：
①class 类A：类A
②class 类B（类A）：类B继承类A

重写

在子类中定义了和父类中名字一样的方法
原因：父类中的代码不能满足子类对象的需要

覆盖式重写

父类中的功能全部不要：直接在子类中定义和父类中的方法名字一样的方法接口，直接书写新的代码

扩展式重写

父类中的功能还需要，添加新的功能：
①先在子类中定义和父类中名字相同的方法
②在子类代码中 使用 super（）. 方法名（）调用父类中的功能

私有和公有

公有权限

直接定义的属性和方法就是公有的

特点：可以在任何地方访问和使用，只要有对象就可以访问和使用

私有权限

只能在类内部定义（class 关键字的缩进中）

需要在 属性名 或者 方法名 前边加上两个 下划线，这个方法或者属性就变为私有的

对象

类对象

使用 class 定义的类

在代码执行的时候，解释器会自动的创建

作用：
①使用类对象创建 实例对象
②存储一些类的特征值（类属性）

实例对象

使用 类名（） 创建的对象

①创建对象也称为实例化 ，所以 由类对象（类）穿件的对象 称为 实例对象，简称 实例
②一般来说，没有进行特殊强调的，都是指 实例对象