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)
161
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
