第一次写python（一）
Day 01
1、快捷键：
快速复制：Ctrl+D
垂直拆分 水平 拆分
快速修改
查看
2、计算机的组成
硬件：运算器 控制器 存储器 输入设备 输出设备
软件： 系统软件 windows10
应用软件 qq 微信
编程语言
人与计算机进行交流的语言
c python java php c++ go
3、python的发展史 优缺点 就业方向
诞生的时间：1991年
python作者： 龟叔
python的两个版本3.6.2和3.7
优缺点：
优点：简单、易学、免费、开源、
高层语言、可移植性强
解释型语言、面向对象
可拓展性、丰富的库、规范的代码
缺点：执行效率慢
就业方向：
1、web开发 ------美多商城 实验楼
2、运维工程师 ----------维护服务器 通过python写脚本
3、爬虫工程师 ----------爬取数据 数据分析
4、游戏开发 AI识别 桌面软件
4、第一个python程序
输出 helloworld
注意 在python里 双引（单）号里是不能套双（单引号）
双（单）引号里能套单（双）引号
5、注释
单行注释 一个 #
快速注释 Ctrl+/
多行注释 ''' '''
作用 对代码进行解释说明
注意 注释的代码或者文字不会被运行
6、变量：用来存储数据
一个 = 是赋值
两个 == 等于
输入input（）
输出print（）
输出为文字或字母时要加引号 print(“aaaa”) print("三大")
输出为数字可加可不加 print(12345)
python的变量：
变量(变化的量)： 用来存储数据
检测变量类型 tupe（）
num=111
print(type(num))
例：
str 字符串（只要加引号的都是字符串）
name = "亚索"
print(type(name))
例：
float 浮点型（小数）
num2 = 6.66
print(type(num2))
例：
类型
str 字符串 ‘4’ ‘张三’ 需要掌握的方法 23种
list 列表 [1,2'张三'，{’name’：’李四’}] 增删改查
dict 字典 {’name’；’张三’} 以键值对存在
set 集合 {1，2，3，4}
tuple 元组 (1,2,3,4)
布尔类型 True False
int 整数
float 浮点数
type() 查看变量的数据类型
Day 2
标识符和关键字
生活中的标识符？
KTV 网吧 酒吧 宾馆 红绿灯 斑马线
作用：提示 见名思意
代码中的标识符？
变量名、函数名、类名
定义：开发人员在程序中定义的名字和符号
命名规则：
1、由字母数字下划线组成 JQ_521_money
2、不能以数字开头 521_Jwq
3、不能使用关键字
如何查看python中的关键字？
a、导包 import keyword
b、使用keyword、kwlist
c、输出
import keyword
print(keyword.kwlist)
命名方法--驼峰命名法
大驼峰命名法：每一个单词的首字母大写 ZhangHao
小驼峰命名法：每一个单词的首字母小写，第二个单词的首字母大写 zhangHao
下划线命名法：由下划线组成
四、输入 输出 格式化输出
2、输入输出
输入
input（） 输入的数据类型-----一定/必须/肯定/是字符串str
输出
print（）
格式化输出
print（’% ’% ’变量名）
%d----int 整数
%f-----float 小数 默认六位 .2f 两位
%s-----str 字符串
一、%用法
注：前面有几个格式化输出符号，后面就要匹配几个变量，个数一一对应。
1、字符串输出 %s（只要是input输入的变量类型都为字符串）
2、整形输出 %d（可加减乘除）
3、浮点型输出 %f（保留几位小数在中间加.几，如%.2f保留两位）
二、逗号隔开
（\n换行\t空格）
需求格式化输出自己的姓名 年龄 性别爱好
需求2 模拟手机充值场景
计算机输出：欢迎使用中国移动充值业务，请输入充值金额：
用户输入：100
计算机输出：充值成功，您本次充值100元
五、运算符
运算符
+ -* %(取余) //整除 **指数
3/2 余数是1 3//2 1
3/3 余数是0 3//5 0
1kb=1024kb
1G=1024mb
1T=1024g
1、算术运算符
2、比较运算符
3、赋值预算符 =
4、复合赋值运算符
+= -= *= /= //= %= **=
数据类型之间的转换
int()
float()
tuple()
set()
list()
chr（） 将数字转换为字母 #A -Z 用ASCII转换 对应的数字65--90
ord（） 将字母转换为数字 #a -z 用ASCII转换 对应的数字97--122
5、逻辑运算符
例：
6、关系运算符
> < >= <= == !=
== 判断两个变量的值 是否相等
六、if--else
基本语法：
if 判断条件：
条件成立执行操作
else：
条件不成立执行操作
例：
多条件判断
if 判断条件：
条件成立执行操作
elif 判断条件2：
条件2成立执行
else：
条件不成立执行操作
例：
导入随机数
# import random
# random.randint(范围)
例：
死循环 while/while True
Day3
七、while循环
一、循环介绍
1. while和if的用法基本类似，
区别在于：if 条件成立，则执行一次；
while 条件成立，则重复执行，直到条件不成立为止。
2. 一般情况下，需要多次重复执行的代码，都可以用循环的方式来完成
3. 循环不是必须要使用的，但是为了提高代码的重复使用率，所以有经验的开发者都
会采用循环
二、基本语法：
初始值
while 循环条件：
步长
三、循环嵌套
while 条件1：
条件1满足做的事
····
while 条件2：
条件2满足做的事
···
打印直角三角形
Day4
八、for循环
在Python中 for循环可以遍历任何序列的项目，如一个列表或者一个字符串等。
for循环语法：
for 变量名 in 字符串/数据类型：
print（“变量名”）
在循环数字的时候 需要用到range 函数,范围 包头不包尾
例：for i in range（1，9）1<=i<9
range（起始值，终止值，步长值）
如果 起始值>终止值 步长值为 正 默认是1 可以不写
for i in range(1,9)///// for i in range(1,9,2)
如果 起始值<终止值 步长值为 负 步长值必须写
for i in range(9,1,-1)
九九乘法表
break 立即终止循环
continue 结束本次循环 继续下个循环
pass 占位符
九、索引和切片
1、索引/下标
第一个元素的下标是从0开始的
最后一个元素的下标是-1
通过下标 可以找到相对应的元素
通过元素找到字符串里的元素下标
用find（）查找元素在字符串里的下标
2、切片
语法：[起始下标：终止下标：步长值]
<包头不包尾>
起始 < 终止 步长为正，默认为1，可不写
起始 > 终止 步长为负，步长值必须写
[:] 正着输出全部
[::-1] 倒着输出全部
Day5
一、字符串中的拼接 +
1、同一个数据类型 直接使用
2、当数字类型和字符串类型相加时，需要把数字类型用str()转换成字符串类型
需求 用字符串拼接 输出 我今天走了12345步
例：str_3="我今天走了"
str_4=1234
str_5="步"
print(str_3+str(str_4)+str_5)
二、计算字符串的长度 len（）
例：
str_1="李源"
print(len(str_1))
了解：（要了解一个字符串所占的字节数
在python中 数字 英文 小数点 下划线 空格 占一个字节
汉字占 3个字符
python编码方式 utf-8
计算机的编码方式 GBK
encode 编码
decode 解码）
三、字符串的分割、合并
分割 split() 就是把字符串分割成列表
split(self,sep,maxsplit)
sep 代表 你想用什么去区分 默认是None 即空格 \t
例：
str="1234,5,6,78,90"
print(str.split(","))
maxsplit 可选参数
合并
join（）把列表再还原成字符串
# 拼接还原
例：
str6=['张三','李四','黄牛','123']
str10=" "
print(str10.join(str6))
count() 统计某个元素在字符串里出现的次数
index() 用来查找某个元素的下标 如果没有该元素 会报错
find() 用来查找某个元素的下标 如果没有该元素 返回-1
rfind() 从字符串的右边往左查找下标
endswith() 判断字符串是否以xx结尾
startswith() 判断字符串是否以xx开头
upper() 将字符串中所有的小写字母转换为大写
lower() 将字符串中所有的大写字母转换为小写
title() 将字符串中所有的单词的首字母大写
capitalize() 将字符串中第一个单词的首字母大写
strip() 去除空格的
lstrip() 去除字符串左边的空格
rstrip() 去除字符串右边的空格
isalnum() 判断字符串中的元素是否都是字母/数字/数字+数字
isalpha() 判断字符串中元素是否全是字母
isdigit() 判断字符串中的元素是否都是数字
isspace() 判断字符串中的元素是否都是空格
replace() ('旧值'，'新值'，3) 替换 3代表替换3个
islower() 判断字符串中的字母是否是小写
isupper() 判断字符串中的字母是否是大写
center() 居中
代码:
# 1、count() 统计某个元素在字符串里出现的次数
str='a411323b19970808c0001'
print(str.count("0"))
5
# 2、index() 用来查找某个元素的下标，如果没有该元素 会报错
str='a411323b19970808c0001'
print(str.index("4"))
1
# 3、 find() 用来查找某个元素的下标，如果没有该元素 返回-1
str='a411323b19970808c0001'
print(str.find('100'))
-1
# 4、 endswith() 判断字符串是否以xx结尾
str='a411323b19970808c0001'
print(str.endswith('2'))
False
# 5、starswith() 判断字符串是否以xx开头
str0808c0001'
print(st='a411323b1997r.startswith("a"))
True
# 6、upper() 将字符串中所有的小写字母转换为大写
str='a411323b19970808c0001'
print(str.upper())
A411323B19970808C0001
# 7、lower() 将字符串中所有的大写字母转换为小写
str='a411323b19970808c0001'
print(str.lower())
a411323b19970808c0001
# 8、title() 将字符串中所有的单词的首字母大写
str='ac411323b19970808c0001'
print(str.title())
Ac411323B19970808C0001
# 9、capitalize() 将字符串中第一个单词的首字母大写
str='a411323b19970808c0001'
print(str.capitalize())
A411323b19970808c0001
# 10、strip() 去除字符串两边的空格
str=' a411323b19970808c0001 '
print(str.strip())
a411323b19970808c0001
# 11、rstrip() 去除字符串右边的空格
str=' a411323b19970808c0001 '
print(str.rstrip())
a411323b19970808c0001
# 11、lstrip() 去除字符串右左边的空格
str=' a411323b19970808c0001 '
print(str.lstrip())
a411323b19970808c0001
# 12、isdigit() 判断字符串里是否都是数字
str=' a411323b19970808c0001 '
print(str.isdigit())
False
# 13、replace() （'旧值'，'新值'，3） 替换 3代表替换3个
str='asd411323,ba19970808,ca0001'
print(str.replace("a","e",2))
esd411323,be19970808,ca0001
# 14、isalnum()
str='asd411323ba19970808ca0001'
print(str.isalnum())
True
# 15、isalpha()
str='asd411323ba19970808ca0001'
print(str.isalpha())
False
# 16、isspance()
str='asd411323ba19970808ca0001'
print(str.isspace())
False
Day6
列表
1、是有一系列按照特定顺序排列元素组成的
2、把元素放在一个[ ],每两个相邻的以' ，'
3、隔开里面的元素，可以是 数字、str、dict、set、list、tuple等任何数据类型
4、列表很牛叉！
创建列表
1、以赋值的方式 =
2、可以创建空列表
3、可以创建数值列表 使用list()
删除列表
del+列表名
访问列表元素
有下标
索引
切片
循环遍历列表 用for
会输出列表中的元素和元素对应的下标 用enumerate
for i in list_1:
print(i)
for x, i in enumerate(list_1):
print(x,i)
列表方法：
列表的操作
增--- 向列表 里添加元素
1、append() 默认在列表的末尾增加
列表名.append（'要添加的元素'）
list_1=["迪丽热巴",'古力娜扎',"张三",'李四']
list_1.append('李沁')
print(list_1)
2、insert() 根据下标添加的元素
列表名.insert（指定位置的下标，'要添加的元素'）
list_1=["迪丽热巴",'古力娜扎',"张三",'李四']
list_1.insert(2,'李沁')
print(list_1)
3、extend（） 将列表中的元素逐一添加到列表中
列表名.extend（序列名）
list_1=["迪丽热巴",'古力娜扎',"张三",'李四']
list_2=["1,2,3,4"]
list_2.extend(list_1)
print(list_1)
# 删 del
# 根据下标删除相对应的元素
# 1、del 列表名[下标]
list_1=["迪丽热巴",'古力娜扎',"张三",'李四']
del list_1[2]
print(list_1)
# 2、clear() 清空列表
list_1=["迪丽热巴",'古力娜扎',"张三",'李四']
list_1.clear()
print(list_1)
# # 3、remove()
# # 根据元素删除
# # 列表名.remove（元素名）
list_1=["迪丽热巴",'古力娜扎',"张三",'李四']
list_1.remove('迪丽热巴')
print(list_1)
改
# 列表名[下标]=新值
list_1=["迪丽热巴",'古力娜扎',"张三",'李四']
list_1[2]='吉泽明步'
print(list_1)
查
列表的查找元素
访问列表元素
有下标
索引
list_1=["迪丽热巴",'古力娜扎',"张三",'李四']
print(list_1[2:])
切片
其 他方法
count 统计元素在列表中出现的次数
sum 求列表中的数字和 只有列表中全是数字的时候
index 查找元素在列表中的下标 如果没有这个元素会报错
sort 排序-----列表中的元素必须全部是数字类型
列表名.sort（） 什么也不写 默认是升序 reverse=false
列表名.sort（reverse=true） 降序
list=[3,1,4,7]
list
Day7
列表推导式/生成式
格式 [临时变量名、 数值列表] 没有标点符号
列表推导式
# 推导式
list_1=[i for i in range(10)]
print(list_1)
# 用随机模块 范围在（10,100）生成一个列表推导式 有十个数 并求和
import random
num=[random.randint(10,100) for i in range(10)]
print(sum(num))
列表的嵌套 ---列表里放列表
-----掌握在列表里嵌套里找到相对应的元素并修改
元组
定义
1、存放的都是按照特定顺序排列的元素
2、每个元素之间用 ， 隔开
3、用()表示
4、元组和列表里都可以存放 各种数据类型
5、元组是不可变的
和列表不同的是：
列表里的元素可以修改
元组里的元素不可修改
列表和元祖之间可以相互装换？
可以
list ---tuple tuple()
tuple ---list list()
创建
1、= 使用赋值预算符直接创建
2、空元组 （）
3、创建数值元组 tuple(range(1,10))
删除
del+元组名
将元组删除
增 ---no
删 ---no
改 ---no
查 ---yes
下标
切片
tuple_1=(1,2,3,4,5)
print（tuple_1[2:]）
还能被循环遍历元组
其他方法
index 获取下标的
count 查找元素在元祖中出现的次数
sum 求和
有没有排序？ ---no
有没有推导式 ---yes
元组推导式 --会生成一个生成器
--查看生成器用list强转
tuple_=（i for i in range(1,10)）
print(list(tuple_1))
字典 ---dict
定义：
1、以一组组键值对存在的数据的序列
dict_1={"name":"张三"，"age":"16"}
neme叫做字典的 key（键）
"张三"叫做字典的value（值）
2、{} 中间的键值对以 ，隔开
字典的特征：
1、想获取字典的值，是通过键来获取
例：
dict_1={1,2,3,4}
print(dict_1["name"])
2、字典是无序的 没有下标
dict_1={"name":"张三"，"age":"16"}
print（dict_1）
3、字典是可变的 ---增删改查
4、字典的键是唯一的 如果一个键出现多次，会输出最后一个值
5、字典的键必须是不可变的数据类型 ---数字、字符串、元组
字典的创建
1、= 以赋值的方式
2、空字典 {}
3、需要一个映射函数来创建 zip()
格式：
变量名=dict(zip(列表1，列表2))
例：
list1=['name','age','sex']
list2=['张三','20','男']
list3=dict(zip(list1,list2))
print(list3)
4、可以根据指定的键值对创建
例：
name="张三"
age=20
sex="男"
print(dict(name="张三",age=20,sex="男"))
删除
del 字典名
字典的操作:
增
字典名['新键名']=新值
例： 添加 亚索的爱好 通过键=值 来添加
dict_1 = {"name":"张三","age": "16","name": "李四"}
dict_1["hobby"]="阿萨尅"
print(dict_1)
update 可以将两个字典进行合并 如果要合并的字典和原子点的键名相同，那么字典里的值会以要合并的字典的值为准
num_2={"name":"张三","age":18}
num1={"name1":"张三","age1":16}
num1.update(num_2)
print(num1)
删
del 字典名["键名"]
例：del dict_1["age"]
clear() 清空字典
例：dict.clear()
pop（"键名"）根据键名删除值
dict_1.pop("name")
改
字典名["键名"]=新值
例：
dict_1 = {"name":"张三","age": "16","name": "李四"}
dict_1["name"]="黄牛"
print(dict_1)
查
字典的循环遍历
1、items 字典
2、keys 字典的键
3、values 字典的值
例：
dict_1 = {"name":"张三","age": "16","sex": "男"}
for i in dict_1.values(): #循环字典的值
print(i)
for i in dict_1.keys(): #循环字典的键
print(i)
for i in dict_1.items(): # 循环字典
print(i)
4、get("键名"，默认值) 当查的键名不存在的时候 会返回这个键名
没有这个键名 想输出的放法：
dict_1 = {"name":"张三","age": "16","sex": "男"}
print(dict_1.get("hobby","没有这个值"))
用for循环查找这个值:
if "age" in dict_1:
print(dict_1["age"])
else:
print("没有这个值")
其他方法
sum 要是有sum 就必须要确定 字典里的键和值必须都是 数字
要求字典里键的和 用 sum（字典名.keys）
要求字典里值得和 用 sum（字典名.values）
集合 ---set ---无序
定义
1、{}
2、中间的元素用 ，
3、集合里的元素 是唯一的
set1={1，2，3，4，5}
print（srt1）
4、是无序的
创建
1、= 使用赋值运算符创建
2、使用set()函数创建 ---强转
set1=（1，2，3，4，5）
str_1=set(str1)
print(str_1)
3、集合里面的元素不能是 集合/字典/列表 里面的元素不能是可变类型
集合里的元素是不可变的
4、不能使用 {} 来创建空集合
5、创建空集合使用 set()
删除
del 集合名
增
集合名.add(要添加的元素)
一次只能添加一个
例：
2. update() 拼接
例：
删
集合名.pop()随机删除一个元素
set4={1,2,3}
set5={4,5,13}
set5.update(set4)
print(set5)
set5.pop()
2. set5.remove(13)
print(set5)
# remove() 指定元素删除 单词删除
# clear() 清空
# set5.discard(2) 指定元素删除 连续删除
和remove不同的是：
如果要删除的元素不存在 用remove会报错
而discard 不会报错
# 改 ---没有改 因为每一个元素都是唯一的
# 查 ---没有查 因为是无序的 下标不固定
# 循环遍历：
# for i in 集合名：
# print(i)
# 其他方法：
# sum ---元素必须都是数字类型
# 集合的 和并集:
# 交集 &(与字符)
# 共有的部分
# 并集| （管字符）
# 你有 我有 大家的
例：
公共方法
+ 拼接 字符串 列表 元组
* 复制 字符串 列表 元组
in 在 字符串 列表 元组 字典
not in 不在 字符串 列表 元组 字典
内置函数
max 获取最大值
min 获取最小值
len 获取数量的
del 删除元素
函数
定义：
1、我们之前学过很多内置函数 sum() print() range()
这些函数帮助我们能够快速的处理数据 达到目的
2、我们能不能自己定义一些函数 来帮助我们快速的处理数据
3、所谓的自定义函数，就是把一段有规律的可重复的代码块定义为函数
达到 一次定义 多次调用的目的
4、函数的作用 ----提高代码的重复利用率
创建：
if 条件语句
函数名 --- 遵循标识符的命名规则 和命名方法
结构：
def 函数名(形参):
函数体/代码
函数名(实参) ---调用的意思
需要注意：
1、函数只有在调用的时候才能执行
2、函数的执行步骤
函数的参数
def 函数名(形参):
函数体/代码
函数名()
例：
定义选形参
调用选实参
参数分为 形参和实参
形参 就是在函数定义的括号里写的参数
实参 就是在函数电泳的括号里写的参数
注意的是： 实参和形参的个数必须是一样的
练习：使用函数和函数的参数 实现 用户输入账户和密码
判断账户等于root 密码等于123456 的时候 输出 欢迎来到2002A
否则输出用户不存在或密码错误
练习：使用函数和函数的参数 实现 用户输入账户和密码
判断账户等于root 密码等于123456 的时候 输出 欢迎来到2002A
否则输出用户不存在或密码错误 只能输入三次 否则次数用完结束
关键字参数：
某一个参数有一个固定值的时候 那么就可以在定义函数的时候给参数一个固定值
给形参一个值
不定长参数---实参不一定长：
*args 表示形参接受多个实参的值 并将其放到一个元组中
例：
**kwargs 表示形参接受多个实参的值 并且将其放在一个字典中
实参一般是 name=“张三”，age=17
例：
返回值 --return
作用
1、将返回值返回
如果return 返回的是一个值 那么这个值 可以是任意类型
如果return 返回的是多个值 那么这个值 是元组类型
2、结束函数
变量的作用域
局部变量 --- 作用域只能在 函数内部
全局变量 ---作用域在全局 函数内外都可以使用
是否可以在函数内部修改全局变量 ---ok
在函数内部使用global 修改全局变量
用法
global 全局变量名
重新赋值
函数的类型 ---参数 和 返回值 的数量来区分
1、无参 无返
2、无参 有返
3、有参 有返
4、有参 无返
函数的嵌套 ---理解 函数嵌套的执行流程
if for while 列表
两个函数：
内部函数
外部函数
def
匿名函数 ---lambda 表达式
语法
lambda 参数列表：表达式
递归函数
递归？ 有层次 有逻辑 有顺序
在函数内部 自己调用自己 也就是返回自身
阶乘 ？ ------
3 1*2*3
5 1*2*3*4*5
n 1*2*3*4*5.....*n-1 *n
求n的递乘
拆包 ----对函数的返回值进行拆包
元组 字典 列表 进行拆包
对字典 进行拆包 输出的只有字典的键
拆包时定义的变量一定要和 函数的返回值的个数相同
文件
可以在python例 创建文件 读取文件 在文件里写
作用： 存储数据
1、创建和打开文件
语法：
需要用到python 的 内置函数 open（）
变量名 =open（"文件名.txt"，"打开模式"，encoding="utf-8"）
打开模式 1、w 写 write（）
2、r 读 read（）
3、a 追加 append（）
注意： 当模式是 w a 的时候 如果有文件 就打开文件 如果没有回自动创建
当模式是 r 代表只读
2、关闭文件
变量名.close()
3、写入文件内容
变量名.write("内容") #内容是字符串形式
4、读取文件内容
read(n ) 全部读出来 里面有参数 按照字节读
readline() 按行读
readlines() 把内容放在列表里
seek() 指定位置读取内容
seek(字节数) 一个汉字=3个字节数 指定位置添加内容
更便捷的方法： 不关闭就保存
with open("a.txt",r,utf-8) as 变量名：
f.
文件的操作 open（）
文件夹 python中又叫 目录
在 python中 文件夹的操作
os模块
1、对文件进行重新命名
os.rename（'旧名'，'新名'）
2、删除文件
os.remove("文件名")
3、创建文件
os.mkdir（“文件夹”）
4、获取当前目录的路径
os.getcwd（）
5、删除文件
os.rmdir()
相对路径
以当前的路径为中心 去查找 指定的文件
老薛 --- 第一排 第三个位置
老王
绝对路径
1、有盘符 C/D/E/F/
2、可以通过文件的右键中的属性查看位置信息
面向对象 -----函数
处理问题的每一步 都需要亲身去经历
面向过程 ----类
只关注结果 不关注过程
创建对象
对象名=类名（）
1、添加和获取 对象的属性
在创建对象后 自己添加属性
2、在方法内部通过self获取对象的属性
在对象里定义属性 在实例方法里通过self调用
__init__魔法方法
1、在魔法方法 __init__里创建的 属性 以下所有的方法都可以使用
__init__ 作用 变量初始化和赋值
__del__ 删除对象的
__str__ 打印详细信息的 需要用 return 返回信息
# 电脑类
# 实例方法有 品牌 价格 内存 cpu 颜色
# 实例方法 学python 看视频 听音乐 打游戏
# 对象
#通过魔法方法 __init__ 来创建实例属性
例子：
__str__ 通过输出对象名 显示信息 需要使用return 和格式化输出
__del__ 删除对象
继承
子类 --- 是一个类
父类 --- 是一个类
子类继承父类的
单继承
在子类的类名括号里父类的名字就可以啦！！！！
子类之继承一个父类
子类可以使用父类的实例方法和实例属性
多继承
1、在子类的括号里 可以写 多个父亲的名
2、当多个父亲的实例属性和实例方法相同时，
默认调用括号里的第一个父类的实例属性和实例方法
3、当多个父类名对的实例方法不用时 子类调用时，互不影响
1、子类重写和父类相同的属性和方法
当子类的属性和方法与子类的属性方法相同时 有限使用子类的
2、在子类中调用父类相同的属性和方法
一、
1、先写一个方法名
2、用父类名.__init__(self)
3、调用实例属性 self.属性名
4调用实例方法 父亲名.方法名(self)
二、
使用super（） 调用父类的方法
1、先写一个方法名
2、用super（）.__init__()
4调用实例方法 super().方法名()
私有属性和私有方法
1、创建私有属性和私有方法
self.__属性名
def __方法名(self):
2、不能被对象调用
不能被继承
处理类内部的事情 起到安全作用
3、通过公有的实例方法修改和调用私有方法
实例方法可不可以调用私有属性 ———yes
通过实例方法可不可以修改私有属性的值 ---yes
面向对象的三大特征：
封装
（概念）封装的意义：
1、将属性和方法 封装到类里 通过对象调用
2、用户是对象 ———实例属性 实例方法 不清楚为我们类里的数据结构
3、只有使用的 没有修改权限 提高了程序的可维护性
继承
实现重复利用的重要手段
子类可以拥有父类的实例属性和实例方法，还可以用自己的实例属性和实例方法
多态
子类继承了父类特征的同时，也具备了自己的特征，并且能够实现不同的效果
实例属性
定义在 __init__ 方法里 以self.开头的属性
对象和实例方法都可以调用实例属性
类属性
在创建类后 直接 用变量名定义的属性
公有类属性
私有类属性
1、实例方法不可以调用类属性
2、对象可以调用公有类属性
3、通过对象修改类属性
类方法 和 静态方法
1、创建
@classmethod
def 方法名(cls):
print（cls.类属性）
2、类方法可以修改类属性
静态方法
1、创建
@staricmethod
def 方法名():
print（通过 类名.类属性名 调用）
2、通过兑现调用
通过类名.方法名调用
__init__和__new__方法
__new__ (了解)
1、参数是 cls
2、必须有返回值
3、返回的是 实例 一般使用 object.__new__(cls)
单例模式
1、异常 ———报错
特征：代码报错之后 下面的代码不能被运行
捕获异常
try ----except 异常
异常处理中抛出异常
try：
except exception as a:
print(e)
（整体结构） 异常处理中抛出对象
try：
except exception as e: 捕获异常
print(e)
else： 没有异常 执行
print('1111')
finally: 无论是否有错 都会执行
print('')
代码错误类型：
NameError 变量名不存在
TypeError 类型错误
SyntaxError 语法错误
ImportError 导入语法错误
IndentationError 缩进错误
IoError 输入输出错误
IndexError 索引超出范围错误
AttributeError 属性错误
2、模块
导包 导python中自带的包
import os
import random
from random import* *代表random里的所有函数
form random import randint
变量名=randint(范围)
自定义模块
import Demo
data=Demo.func(4,5)
print(data)
浙公网安备 33010602011771号