python学习笔记
面向对象
初始对象
相当于结构体
定义形式
class 名字:
成员变量
调用:
名字.成员变量
成员方法
类的定义
class 类名称:
类的属性
类的行为
class是关键字,表示要定义类
类的属性,即定义在类中的变量(成员变量)
类的行为,即定义在类中的函数(成员方法)
创建类对象的语法
对象 = 类名称()
成员方法定义语法
def 方法名(self,形参1,形参2,。。。。,形参N)
方法体
定义方法是参数列表,必须有一个self关键字
表示类对象本身的意思
只有通过self,成员方法才能访问类的成员变量
self出现在形参列表中,但是不占用参数位置,不用理会
类和对象
类是程序中的设计图纸
对象是基于图纸生产的具体实体
面向对象编程,就是使用对象进行编程
即,设计类,基于类创建对象,并使用对象来完成具体的工作
构造方法
__init__()
语法:
class 类名称:
def __init__(self,形参1,形参2,形参3)
self.形参1 = 形参1
self.形参2 = 形参2
self.形参3 = 形参3
调用:
对象 = 类名称(形参1,形参2,形参3)
在创建对象(构造类)的时候,会自动执行
在创建对象(构造类)的时候,将传入参数自动传递给__init__方法使用
封装
将现实世界事物在类中描述为属性和方法,即为封装。
私有成员
现实事物有部分属性和行为是不公开对使用者开放的。同样在类中措述
属性和方法的时候也需要达到这个要求,就霄要定义私有成员了
定义:成员交量和成负方法的命名均以__作为开头即可
访问限制:类对象无法访问私有成员
类中的其它成员可以访问私有成员
继承
单继承
语法:
class 子类名(父类名):
类内容体
多继承
语法:
class 子类名(分类1,父类2,。。。,父类N)
类内容体
多个父类中,如果有同名的成员,默认以继承顺序(从左到右)为优先级。即先继承的保留,后继承的被覆盖
pass关键字
pass是占位语句,用来保证函数(方法)或类定义的完整性,表示无内容,空的意思
复写
子类继承父类的成员属性和成员方法后,如果对其不满意,那么可以进行复写。即在子类中重新定义同名的属性或方法即可
调用父类同名成员
一旦复写父类成员, 那么类对象调用成员的时候,就会调用复写后的新成员。如果需要使用被复写的父类的成员,需要特殊的调用方式
方式一
使用成员变量:父类名.成员变量
使用成员方法:父类名.成员方法(self)
方式二
使用成员变量:super().成员变量
使用成员方法:super().成员方法()
类型注解
变量的类型注解
基础语法: 变量:类型
基础数据类型注解
var_ 1: int = 10
var_ 2: float = 3.1415926
var_ 3: boo1 = True
var_ 4: str =‘ i thei ma'
类对象类型注解
class Student:
pass
stu: Student = Student()
基础容器类型注解
my_ list:1ist = [1,2,3]
my_ tuple: tup1e = (1,2,3)
my_ set:set ={1,2,3}
my_ dict: dict = {"itheima": 666}
my_ str:str = "ithei ma”
容器类型详细注解
my_ list:list[int] = [1,2,3]
my_ tuple: tup1e[str, int, boo1] = ("itheima",666, True)
my_ set: set[int] = {1,2,3}
my_ dict: dict[str, int] = {"itheima": 666}
在注释中进行类型注解
class student:
pass
var_ 1 = random. randint(1,10)# type: int
var_ 2 = json.1oads (data)# type: dict[str, int]
var_3 = func() # type: Student
函数(方法)的类型注解
语法:
def 函数方法名(形参名:类型,形参名:类型,。。。。)->返回值类型:
pass
Union类型
my_ _list: list[union(int, str)] = [1, 2,"itcast", "itheima"]
my_ _dict: dict[str, Union[str, int]] ={"name": "周杰轮","age": 31}
def func(data: Union[int, str]) -> Union[int, str]:
pass
联合类型注解
导包: from typing import Union
使用:Union[类型,。。。,类型]
多态
以父类做定义声明,以子类做实际工作,用以获得同一行为,不同状态
基础语法
字面量
字面量:在代码中,被写下来的固定值,称之为字面量
常用的6类值
数字(Number)
整形(int)
如: 10、-10
浮点型(float)
如: 13.14、-13.14
复数(complex)
如: 4+3j,以j结尾
布尔(bool)
表达真、假。Ture表示为真(本质为1);Flase表示为假(本质为0)
布尔类型不仅可以自行定义同时也可以通过计算的来。
也就是使用比较运算符进行比较运算得到布尔类型的结果。
比较运算符
==(是否相等,满足为True,不满足为Flase)
!=(是否不相等,满足为True,不满足为Flase)
>(是否大于,满足为True,不满足为Flase)
<(是否小于,满足为True,不满足为Flase)
>=(是否大于等于,满足为True,不满足为Flase)
<=(是否小于等于,满足为True,不满足为Flase)
字符串(string)
描述文本的一种数据类型
在Python中,字符串需要用双引号”包围起来,被引号包围起来的,都是字符串
定义方式
单引号定义 name = ‘afaf’
双引号定义 name = “gsegfes”
三引号定义 name = """ afafgui """
引号嵌套
使用 \来进行转义
单引号内可以写双引号 或 双引号内可以写单引号
字符串的拼接
如果我们有两个字符串(文本)字面量,可以将其拼接成-一个字符串,通过+号即可完成,如:print("马"+ "过万")
无法和非字符串类型进行拼接
字符串格式化
完成字符串和变量的快速拼接
name = "afhaoi"
message = "afa %s"%name
%表示:我要占位
s表示:将变量变成字符串放入占位的地方
多变量占位
变量要用括号括起来
并按照占位的顺序填入
message = “发发%s,faf%s”%(num1,num2)
数字精度控制
我们可以使用辅助符号"m.n"来控制数据的宽度和精度
m,控制宽度,要求是数字(很少使用) ,设置的宽度小于数字自身,不生效
.n,控制小数点精度,要求是数字,会进行小数的四舍五入
●%5.2f: 表示将宽度控制为5,将小数点精度设置为2
小数点和小数部分也算入宽度计算。如,对11.345设置了%7.2f后,结果是: [空格][空格]11.35。2个空格补足宽度
小数部分限制2位精度后,四舍五入为.35
快速写法
pirnt(f"afafhui{num}")
表达式格式化
print(f"fahfauh{1*1}")
制表符\t
让多行字符串进行对齐
列表(List)
有序可变序列
元组(Tuple)
有序不可变序列
集合(Set)
无序不重复集合
字典(Dictionary)
无序Key-Vaule集合
注释
在程序代码中对程序代码进行解释说明的文字。
单行注释:以#开头, #右边的所有文字当作说明,不是真正要执行的程序,起辅助说明作用
# 和注释文字的内容包含有一个空格
多行注释:以一 对三个双引号引起来注释来解释说明一段代码的作用使用方法
变量
变量:在程序运行时,能储存计算结果或能表示值的抽象概念。
简单的说,变量就是在程序运行时,记录数据用的
定义格式:变量名称 = 变量的值
数据类型
使用函数 type()
数据类型转换
int(x)
将x转换为一个整数
x为字符串,里的内容必须为数字,才可以将字符串转换为整型数据
float(x)
将x转换为一个浮点数
str(x)
将x转换为字符串
任何数据,都可以通过str(),转换为字符串
标识符
在Python起名字称为标识符
不推荐使用中文、数字不可以开头、不可以使用关键字命名
运算符
算术运算符
+(加)、-(减)、*(乘)、/(除)、//(取整除)、%(求余)、**(指数)
幅值运算符
=
符合幅值运算符
+=(加法赋值)、-=(减法赋值)、*=(乘法赋值)、/=(除法赋值)、%=(取模赋值)、**=(幂赋值)
数据输入
input()
无论键盘输入什么类型的数据,获取到的都是字符串类型,需要进数据类型转换
判断语句
if判断语句
if 要判断的条件:
条件成立,要做的事
elif 要判断的条件:
条件成立,要做的事
else:
条件不成立,要做的事
elif可以写多个
判断是互斥且有序的,上一个满足后面的就不会判断了
if判断语句的嵌套
嵌套的关键在于:空格缩进,用空格的缩进来决定语句之间的:层次关系
循环语句
while循环语句
while 条件:
条件满足,执行
只要条件满足会无限循环执行
while循环语句嵌套,也用空格缩进行
for循环语句
for 临时变量 in 待处理数据集:
循环满足条件时执行的代码
从待处理数据集中,逐个取出数据赋值给临时变量
range语句,语法range(num1,num2,step)
获得一个简单的数字序列
for循环的变量作用域
在for循环外部访问临时变量
实际上可以访问但只要最后一个数且代码不规范
循环中断 break和continue
break关键字用于
直接结束所在循环
continue关键字用于
中断本次循环,直接进入下一次循环
文件操作
文件打开
open(name,mode,encoding)
name:要打开的目标文件名的字符串(可以包含文件所在的具体路径)。
mode: 设置打开文件的模式(访问模式):只读、写入、追加等。
encoding:编码格式(推荐使用UTF-8)
f: = open( python.txt', 'r', encoding=" UTF-8)
mode 模式的区别
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w,打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,原有内容会被删除。
如果该文件不存在,创建新文件。
a,打开一个文件用于追加。如果该文件已存在,新的内容将会被写入到已有内容之后。
如果该文件不存在,创建新文件进行写入。
文件读
文件对象.read(num)
num表示要从文件中读取的数据的长度(单位是字节),如果没有传入num,那么就表示读取文件中所有的数据。
readlines()方法:
readlines可以按照行的方式把整个文件中的内容进行一次性读取,并且返回的是一个列表, 其中每行的数据为一个
元愫。
readline()方法: -次读取- -行内容
for循环读取文件行
for line in open(" python.txt", "r"):
print(line)
文件关闭
close(关闭文件对象
f = open("python.txt",' ")
f.close()
with open.语法
with open(" python.txt", "r") as f:
f.readlines()
#通过在with open的语句块中对文件进行操作
#可以在操作完成后自动关闭close文件,避免遗忘掉close方法
文件写入
# 1.开文件
f = open( python.txt', 'w')
# 2.文件写入
f.write('hello world')
# 3.内容刷新
f.flush()
文件如果不存在,使用”w"模式,会创建新文件
文件如果存在,使用”w"模式,会将原有内容清空
文件追加
# 1.打开文件,通过a模式打开即可
f = open("python.txt', 'a")
# 2.文件写入
f.write("hello world")
# 3.内容刷新
f.flush()
数据容器
一种可以容纳多份数据的数据类型,容纳的每一份数据称之为1个元素,每一个元素,可以是任意类型的数据,如字符串、数字、布尔等
列表(list)
定义列表 :变量名称 = [元素1,元素2,元素3,元素4,。。。]
定义空列表
变量名称 = []
变量名称 = list()
以[]作为标识,列表内每一个元素之间用,逗号隔开
列表的下标索引
列表中的每一个元素,都有其位置下标索引,从前往后,从0开始,依次递增
或者 反向索引,从后往前,从-1开始,依次递减
取出元素
列表[下标],即可取出
要注意下标索引的取值范围,超出范围无法取出元素,并且会报错
列表的常用操作
列表的查询功能
语法:列表.index(元素)
列表的修改功能
修改指定位置(索引)的元素值
语法:列表[下标]=值
插入元素
语法:列表.insert(下标,元素),在指定的下标位置,插入指定的元素
追加元素
语法:列表.append(元素),将指定元素,追加到列表的尾部
追加元素2
语法:列表.extend(其它数据容器),将其它数据容器的内容取出,依次追加到列表尾部
删除元素
语法1: del列表[下标]
语法2:列表.pop(下标)
删除某元素在列表中的第一个匹配项
语法:列表.remove(元素)
清空列表内容
语法:列表.clear()
统计某元素在列表内的数量
语法:列表.count(元素)
统计列表内,有多少元素
语法:len(列表)
列表的遍历
既然数据容器可以存储多个元素,那么,就会有需求从容器内依次取出元素取出元素进行操作。将容器内的元素依次取出进行处理的行为,称之为:遍历、迭代。
index = 0
while index < len(列表)
元素 = 列表[index]
对元素进行处理
index += 1
for 临时变量 in 数据容器:
对临时变量进行处理
元组(tuple)
元组一旦定义完成,就不可以修改
定义元组变量:
变量名称 = (元素,元素,。。。。,元素)
定义空元组
变量名称 = ()
变量名称 = tuple()
元组支持嵌套
定义一个嵌套元组
t1 = ((1,2),(3,4))
元组的相关操作
index()
查找某个数据,如果数据存在返回对应的下标,否则报错
count()
统计某个数据在当前元组出现的次数
len(元组)
统计元组内的元素个数
元组的遍历
for 临时变量 in 数据容器:
对临时变量进行处理
index = 0
while index < len(列表)
元素 = 列表[index]
对元素进行处理
index += 1
字符串(str)
字符串是字符的容器,一个字符串可以存放任意数量的字符
字符串的下标
从前向后,下标从0开始
从后向前,下标从-1开始
同元组一样,字符串是一个无法修改的容器
字符串的相关操作
查找特定字符串的下标索引值
语法:字符串.index(字符串)
字符串的替换
语法:字符串.replace(字符串1,字符串2)
不是修改字符串本身,而是得到新的字符串
字符串的分割
语法:字符串.split(分隔符字符串)
字符串本身不变,而是得到了一个列表对象
字符串的规整操作(去前后空格)
语法:字符串.strip()
字符串的规整操作(去前后指定字符串)
语法:字符串.strip(字符串)
统计字符串中某字符串的出现次数
语法:字符串.count(字符串)
统计字符串长度
语法:len(字符串)
字符串的遍历
for 临时变量 in 数据容器:
对临时变量进行处理
index = 0
while index < len(列表)
元素 = 列表[index]
对元素进行处理
index += 1
序列
列表、元组、字符串,均可以视为序列
切片
从一个序列中,取出一个子序列
语法:序列[起始下标:结束下标:步长]
不会影响序列本身,而是会得到一个新的序列
集合(set)
列表可修改、支持重复元素且有序
元组、字符串不可修改、支持重复元素且有序
但具有局限性,它们支持重复元素,而集合就是不支持元素的重复(自带取出功能)、并且内容无序
定义集合变量
变量名称 = {元素,元素,。。。,元素}
定义空集合
变量名称 = set()
集合是无序的,不支持下标索引访问
集合的常用操作
添加新元素
语法:add(元素)
集合本身被修改,添加了新元素
移除元素
语法:集合.remove(元素)
集合本身被修改,移除了元素
从集合中随机取出元素
语法:集合.pop()
会得到一个元素的结果。同时集合本身被修改,元素被移除
清空集合
语法:集合.clear()
取出2个集合的差集
语法:集合1.difference(集合2)
取出集合1和集合2的差集
消除2个集合的差集
语法:集合1.difference_update(集合2)
在集合1内,删除和集合2相同的元素
2个集合合并
语法:集合1.union(集合2)
将集合1和集合2组合成新集合
查看集合的元素数量
语法:len(集合)
统计集合内有多少元素
for循环遍历
集合不支持下标索引,所以也就不支持使用while循环
for 临时变量 in 数据容器:
对临时变量进行处理
字典(dict)
定义字典
dict = {key:vaule,key:vaule,....,key:vaule}
定义空字典
dict = {}
dict = dict()
字典同集合一样,不可以使用下标索引
但是字典可以通过key值来取得对应的Vaule
字典可以嵌套
字典的常用操作
新增元素
语法: 字典[key] = vaule
字典被修改,新增了元素
更新元素
语法:字典[key]=vaule
字典被修改,元素被更新
删除元素
语法:字典.pop(key)
清空字典
语法:字典.clear()
获取全部的key
语法:字典.keys()
遍历字典
语法:for key in 字典.keys()
计算字典内的全部元素(键值对)数量
语法:len(字典)
分类
是否支持下标索引
支持
列表、元组、字符串-序列类型
不支持
集合、字典-非序列类型
是否支持重复元素
支持
列表、元组、字符串-序列类型
不支持
集合、字典-非序列类型
是否可以修改
支持
列表、集合、字典
不支持
元组、字符串
数据容器的通用统计功能
len(容器)
max(容器)
类型转换
list(容器)
str(容器)
tuple(容器)
set(容器)
排序
sorted(容器,[reverse = True])
函数
函数:是组织好的,可重复使用的,用来实现特定功能的代码段
def 函数名(传入参数)
函数体
return 返回值
调用: 函数名(参数)
函数的传入参数
传入参数的功能是:在函数进行计算的时候,接受外部调用提供的数据
函数的返回值
返回值,就是程序中函数完成事情后,最后给调用者的结果
None 类型:表示空的、无实际意义的意思
如果函数没有使用return语句返回数据,函数的返回值是None
None的应用场景,用在if判断中,None=Flase
一般用于函数中主动返回None,配合if判断做相关处理
None的应用场景,用于声明无内容的变量上
定义变量,但暂时不需要变量有具体值,可以用None代替
变量的作用域
局部变量
在函数体内部,临时保存数据,即当函数调用完成后,则销毁局部变量
全局变量
指的是在函数体内、外都能生效的变量
global关键字
使用该关键字可以在函数内部声明变量为全局变量
函数多返回值
def 函数():
return 1,2
函数多种传参方式
位置参数
调用函数时根据函数定义的参数位置来传递参数
def 函数(name,age,gender)
调用:函数(name,age,gender)
传递的参数和定义的参数的顺序及个数必须一致
关键字参数
函数调用时通过“键=值”形式传递参数
作用:可以让函数更加清晰,容易使用,同时也清除了参数的顺序需求
def 函数(name,age,gender)
调用:函数(name,age=20,gender="男")
函数调用时,如果有位置参数时,位置参数必须在关键字参数的前面,但关键字参数之间不存在先后顺序
缺省参数
缺省参数:缺省参数也叫默认参数,用于定义函数,为参数提供默认值,调用函数时可不传该默认参数的值(注意:所
有位置参数必须出现在默认参数前,包括函数定义和调用) .
作用:当调用函数时没有传递参数,就会使用默认是用缺省参数对应的值.
函数调用时,如果为缺省参数传值则修改默认参数值,否则使用这个默认值
def user_ info(name, age, gender='男'):
print(f'您的名字是{name},年龄是{age}, 性别是{gender}')
user_ info('TOM', 20)
user_ info('Rose', 18,'女')
不定长参数
不定长参数: .
不定长参数也叫可变参数用于不确定调用的时候会传递多少个参数(不传参也可以的场景
作用:当调用函数时不确定参数个数时,可以使用不定长参数
传进的所有参数都会被args变量收集,它会根据传进参数的位置合并为-个元组(tuple), args是元组类型, 这就是位置传
递
def user_ info(*args):
print(args)
# ('TOM',)
user_ info( 'TOM' )
# ('TOM',18)
user_ info( 'TOM',18)
参数是“键=值"形式的形式的情况下,所有的“键=值"都会被kwergs接受,同时会根据“键=值"组成字典
def user_ info(**kwargs) :
print( kwargs )
# {'name': 'TOM' ,
age': 18,'id': 110}
user_ info(name='TOM', age=18, id=110)
函数作为参数传递
lamdba匿名函数
函数的定义中
def关键字,可以定义带有名称的函数
lambda关键字,可以定义匿名函数(无名称)
有名称的函数,可以基于名称重复使用。
无名称的匿名函数,只可临时使用一次。
lambda传入参数:函数体(一行代码)
test_ .func(lambda x,y:x+y)