python是由荷兰人 (Guido van Rossum)吉多.范.罗苏姆，于1989年发明的第一个公开发行于1991年。
python的特点
1. python是一种解释性语言 开发过程种没有了编译这个环节 类似于PHP或者Perl语言。
2. python是交互式语言，可以在一个python提示符直接互动执行程序。
3. python是面向对象语言，python支持面向对象的风格或代码封装在对象的编程技术。
4. python是初学者的语言，python对于初级程序员而言是一种伟大的语言，他支持广泛的应用程序开发，从简单的文字处理 到浏览器在到游戏。
5. python是跨平台 它可以运行在windows mac os 或者 Linux系统上也就是说 在windows上书写的python程序在Linux上也可以运行，类似于java。
python的优点
易于学习 python有相对较少的关键字 结构 简单和一个明确定义的语法，学习起来更加简单。
易于阅读 python代码更加定义的更清晰。
易于维护 python的成功在于它的源代码是相当容易维护的。
一个广发的标准库，python的最大的优势之一是丰富的库，跨平台的在在nuix weindows 和 mac os 上的兼容性很好。
互动模式 互动模式的支持可以从终端输入执行代码并获得结果的语言 互动的测试和调式代码片段。
可移植性 基于其开发源代码的特性，python已经被移植到许多平台。
可扩展性 如果需要一段运行很快的关键代码或者想要编写一些不愿开发的算法，可以使用 C 或者 C++ 完成那部分代码，然后从你的python调用。
数据库 python提供所有主要的商业数据库的接口。
GUI的编程(图形化界面) python支持GUI可以创建和移植到许多系统调用。
可嵌入性 可以将python嵌入到 C 或者 C++ 程序，让你程序的用户获得 “脚本化” 的能力。
python缺点
运行速度慢 和 c 程序相比非常慢，因为python是解释型，语言代码在执行时会一行一行的翻译成CPU能理解的机器码，这个翻译过程非常耗时，所以很慢，而C程序是运行前直接编译成CPU能执行的机器码，所以非常快。
代码不能加密 如果要发布python程序，实际上就是发布源代码这一点跟 C 语言不通， C 语言不用发布源代码，只需要把编译后的机器码就是 windiws 上常见的 xxx.exe 发布出去，要从机器码反推出 C 代码是不可能的，所以凡是编译型的语言，都没有这个问题，而解释型的语言，则必须把源代码发出去
应用场景
web 开发 通过 mod_wsgi 模块 Apache 可以运行用python编写的 web 程序，python定义了 WSGl 标准应用接口来协调 Http 服务器于基于python的 web 程序之间的通信，一些 web 框架 如：Django TurboGears web2py.zope 等，可以让程序员轻松的开发和管理复杂的 web 程序。
操作系统管理 服务器运维的自动化脚本，在很多操作里python标准的系统组件，大多数Linux发行版以及 NeeBSD OpenBSO 和 Mac OS X 都集成在了python，可以在终端下直接运行python，python编写的操作系统管理脚本在 可续性 性能代码重用度 扩展性几方面都优于普通的shell脚本。
网络爬虫 python有大量的 HTTP 请求处理库和HTML解析库 并且有成熟高效的爬虫 框架 Scrapy 和分布或解决方案 scrapy-redis 在爬虫应用方面非常广泛。
科学计算 数据分析 Numpy Scipy Pandas Matppltlib 可以让python程序员编写科学计算程序。
桌面软件 PyQt PySide WXPython PyGTK是python快速开发桌面的应用程序的利器。
服务器软件 网络软件 python对于各种网络协议的支持很完善，因此经常被用于编写服务器软件，网络爬虫，第三方库TWisted支持异步网络，编程和多数标准的网络协议包含客户端和服务器，并且提供了多种工具被广泛用于编写高性能的服务器软件。
游戏 很多游戏使用 C++ 编写图形显示等高性能模块，而使用python或者 Lua 编写游戏的逻辑，服务器相较于python， LUa的功能更简单 体积更小，而python则支持更多的特性和数据类型
搜狐 豆瓣 腾讯 网易 百度 阿里 淘宝 土豆 新浪等都在内部大量的使用python
自己百度👇
动画测试：
运维：
软件测试：
人工自能：
数据分析：
标识符
概念计算机编程语言中标识符是用户编程时使用的名字，用于给变量 常量 函数语句块等命名，以建立起名称与使用之间的关系
- 合法标识符的命名规则：
- 只能由数字 字母 和下划线组成
- 不可以是除了下划线之外的其它的特殊字符
- 开头不能是数字或者是空格
- 不能是python的关键字
- 严格区分大小写 age AGE Age
```
标识符的命名规则：
尽量使用简单的英文单词表示，做到见名知意
具有描述性：
尽量使用简单的英文单词表示遵守。
遵守一定的命名规范：
python官方推荐的命名方式：变量名 函数名 和 文件名 全小写，使用下划线连接，如：stu_name check_qq
驼峰命名法： 不同的单词之间使用首字母大写的方式进行分隔，又分为大驼峰和小驼峰，比如：stuName 就是小驼峰， StuName 就是大驼峰，小驼峰常用于 变量 或 常量 函数的命名，大驼峰常用于类的命名
```
- 关键字：
- 概念：一些具有特殊功能的标识符。
- 注意：关键字已经被python官方使用了所以不允许开发者自己定义和关键字重名的标识符
```
语法： 变量名 = 值
说明： 变量名其实就是标识符
False None True and os assert break class continue def del elif else except finalu for from global if import in is lambda nonlocal not or pass raise return try while with yield
程序在运行的过程中表示的值可以随时发生改变的标识符，在程序设计中，变量是一种村粗数据的载体 容器。
数据类型和变量： 【重点】
常用数据类型：
顾名思义，计算机就是用来做数学的机器，因此计算机程序理所当然的可以处理各种数值，但是计算机能处理的远远不止数值，还可以处理 文本 图形 音频 视频 网页 等各种数据，而处理不同的数据，需要使用不同的数据类型来进行表示
数据型：
整形 int 浮点型 float 复数 complex 布尔型 bool 只有俩个值 True 和Fales True可以当作 1 False可以当作 0
字符串 str " " 列表 list[ ] 元组 tuple ( ) 字典 dict { }
集合 set { } 字节 bytes 空值 None
```
## 输出进阶
```
input 输出的任何都是字符串
sep 分隔符，当输出多个数据的时候，sep默认为空格，也可以自定义分隔符
print("aaa","bbb","ccc",sep="放入什么都可以看面试怎么说")
```
- java 的 ++ 跟python的 += 一样的 意思： n += 1
- 区分 = 跟 == 意思不一样
- and 全真为真 一假为假
- or 全假为假 一真为真
- 注意：逻辑运算的 and 和 or 的结果不一定是布尔值，取决于运算俩边的数据
- 注意：not 得到的结果肯定是布尔值
## 身份运算符
- is 和 == 的区别
- is 比较的是地址
- == 比较的数值
- 0b二进制
- 0o八进制
- 0x十六进制
```
int("0b1120",base=( ))
int(value,base),base 用于声明 value 是什么进制，base 默认为10
```
## 列表的使用
```
作用：列表相当于是一个容器，可以同时存储多种数据。
本质：列表是一个有序的，可变的，可以存储重复元素的集合。
说明：有序指的就是有顺序，数据的存放的顺序和底层存储的顺序是相同的。
注意：append 和 extend 都表示将元素追加到列表的末尾，但是如果添加的是一个容器，append添加容器本身，
extend 打碎加入
remove 删除元素本身，注意：如果有重复元素一次只能删一个元素。
pop 根据索引删除对于元素，index可以省略默认删除最后一个
clear 清空列表
虽然列表是可变的，但是 + 和 x 操作的时候都是生成了一个新的列表，对原则列表没有任何影响。
如果非要用 remove 删除的话，建议使用：(切片) 每遍历一次都会生成新的列表，不再是操作的是原列表，而是生成了一个新的列表
如果不想删除的话可以使用append 加的思路更清晰
```
## 切片
- 阳姐心得 【如果start 和 end 一个为正 一个为负 则参考start的正负性】
```
start：end：step
如果省略 start， 则默认从列表的开头 0 - 1 开始
如果省略 end， 则默认从列表的末尾 0 - 1 结尾
如果省略 step， 则默认为 1
列表 字符串 元组 都可以实现切片
无论切片怎么书写，结果都不会报错，区别在于其中有无元素，如果 end 未被省略则不包含在内，包头不包尾
用start + step 的和判断是否在 start end 区间内 如果不存在 则直接结果为 [ ]
end取的多大，一样能输出
::-1 倒序输出
```
## 列表的拷贝
- 浅拷贝： 只拷贝了列表的最外层
- 深拷贝： 不管嵌套了几层都会被拷贝
```
列表是可变的数据类型，当用 = 赋值时，不管列表是一维 还是 多维列表，如果用其中一个变量名修改其中一个元素，另一个也会修改。
列表.copy( ), copy.copy( ):只有修改一维列表中的元素的时候一个更改，另外一个不会受影响
copy.deepcopy( ) 怎么都不会更改
```
## 列表排序
```
冒泡排序：排序思路，比较俩个相邻的下标，对应的元素，如果符合条件就交换位置，最值出现在最后位。
内层循环：控制的是每一轮比较的次数，以及参与比较的下标
比较：如果符合条件则交换位置
如果下标的的元素 > 下标大的元素则交换位置
选择排序：排序思路，固定一个下标，然后拿着这个下标对应的值，依次和后面的元素进行比较，最值出现在头角位置上
for i in range(len(list1) - 1):
for j in range(i + 1,len(list1)):
if list1[i] > list1[j]
list1[i],list1[j] = list1[j],list1[i]
顺序排序：查找思路：遍历指定列表把要查找的数据依次和列表中的每一位元素进行比较
key = 9
for i in range(len(list1)):
if list1[i] == key:
print(key,i)
break
else:
print("不存在")
二方法查找：查找思路：前提是数组是有序的，升序或者降序的，通过折半来缩小查找范围，提高查找效率，将待查的元素与中间下标对应的元素比较 如果大于中间下标对应的元素 则取右半部分查找
循环计算中间的下标 并且通过比较数的大小重置 left 和 right 的值
while left <= right:
计算中间的下标
middle = (left + right) // 2
用带查找元素和中间下标对应的元素进行比较
以升序为列
if key > list1[middle]:
重置 left 的值
left = middle + 1
elif key < list1[middle]:
重置 right 的值
right = middle - 1
else:
找到了
print(key,middle)
break
else:
print("不存在")
```
## 本质
```
列表的本质：列表是一种有序的 可变的 可以存储重复元素的集合
list 列表 [ ]
元组的本质：元组是一种有序的，但不可变的，可以存储元素的集合
元组 tuple( )
元组和列表的不同之处：
列表[ ] tuple ( )
列表中的元素可以进行增加和删除操作，但是元组中的元素不能修改，元素一旦被初始化，将不能发生改变
字典的本质：字典是一种无序的 可变的 存储键值对但是其中的健不允许重复的集合
字典dict { }
```
## 类型的总结
| 可变的类型： list dict set | | |
| :-----------------------------------------------: | ---- | ---- |
| 不可变的类型： int float bool str tuple | | |
## 字典系统功能
```
update 更新 合并字典 将dict2指定字典中的键值对添加到dict1原字典中
dict1.update(dict2)
谁在前就添加谁
pop(key)根据指定的key删除对应的键值对
popitem()随机删除一对键值对 因为字典是无序的 返回结果为被删除的键值对组成的元素
del( )删除
clear( )清空
len(长度) 获取对应的对数
get( )如果 key 存在，则返回对应的value，如果key不存在，则返回None 如果设置了默认值 则返回默认值
keys( ) 获取所有key
values( ) 所有value
itmes ( ) 所有键值对
```
## 数学功能
```
常用的内置函数
abs( ) 求绝对值
print(abs(-18))
求最值
max 大
min 小
pow(x,y) 求 x 和 y 的次方
print(pow(5,2))
sum(容器)求和
print(sum([5,3]))
print(sum((5,3)10))
round(x,y): 求四舍五入
如果省略y，则结果为四舍五入的整，如果y未被省略则表示需要保留的小数点后的位数
print(round(8.23))
print(round(8.232324,3))
import math
celt( )向上取整 floor 向下取整
sqrt( )求算术平方根 结果为一个浮点型
常量：
math.pi math.e
```
## 列表 元组 字典 和 集合 的区别
$$
列表的本质：是一种有序的，可变的 允许存储重复元素的集合
list[ ]
元组的本质：是一种有序的，不可变的 允许存储重复元素的集合
tuple( )
字典的本质：是一种无序的， 可变的 存储键值对的，集合 但是key不允许重复，而且key必须是不可变的数据类型
dict{ }
集合的本质：是一种无序的， 可变的 不允许存储重复元素的集合
set ( )
$$
## 集合的基本操作
```
字典和集合之间的练习：集合相当于存储了字典中的一组key
交集 & 按位与
并集 | 按位或
差集 -
并集 ————交集 ^ 按位异或
```
## 字符串的操作
```
字符串是不可变的数据类型 但凡涉及到字符串的更改都是生成了一个新的字符串
str1 = "hello"
str1.upprt( ) 没有新的接口，还是会打印原来的
print(str1)
每个单词的首字母大写，其余全部为小写
print(name.title( ))
一句英文的首单词的首字母大写，其余全部小写
print(name.capitalize( ))
小———大 大————小
print(name.swapcase( ))
```
## 函数的定义
- 优点：
- 简化代码的结构，提高应用的模块性
- 提高了代码的复用性
- 提高了代码的维护性
- 提高了代码的可读性
```
* 当做元组处理
** 当做字典处理
*的数量不能出现俩次，只能出现一次
打包和拆包 不管怎么写都是列表 自己去试着考虑
n1,n2,*n3 = 3,4,[5,6,7,8,9]
n1,*n2,n3 = 3,4,[5,6,7,8,9]
*n1,n2,n3 = 3,4,[5,6,7,8,9]
```
## 参数的传递
```
值传递：实参是不可变的数据类型：int float bool str tulpe
当在函数体中对形参进行了修改，对实参没有影响
引用传递：实参是可变的数据类型：list dict set
```
## 匿名函数
```
def fun( )
a = [ ] 函数定义完不会被执行只有调用才会
for i in range(5): 向列表中添加了5个函数【函数的定义】
a.append(lambda x:x * i) i 的取值停留在了4
return a
result 本身是一个列表，其中的元素是函数
result = func( ) result = a
获取result列表中的第0个元素，本质是一个函数
print(result[0])
result[0](2)表示调用列表中的第0个函数，给形参 x 传值 2
print(result[1](2))
print(result[2](2))
print(result[3](2))
print(result[4](2))
```
## 局部变量和全局变量
```
a = 23 全局变量
def show( ):
假如加一个 globala 就不会报错
a += 1
a 还没有被定义所以会报错
show( )
print(a)
```
## 可迭代对象
```
区别：
可迭代对象：Iterable，可以之间用于for循环的数据如：list tuple dict set str 生成器等
迭代器：Iterator 可以之间用于for循环，而且可以使用next( ) 获取元素的数据 如：生成器
联系：
迭代器一定可以迭代对象，但是可迭代对象不一定是迭代器
但是可以通过系统功能iter( ) 将不是迭代器的可迭代对象转换为迭代器]()
```
## 装饰器
```
书写一个装饰器，可以统计一个函数的执行时间
def show( ):
for i in range(100000)
def get_time(func):
def inner( ):
开始时间
start_time = time.time()
调用函数
func()
end_time = time.time()
return end_time - start_time
f = get_time(show)
r = f( )
print(r)
方式二
@get_time
r = show( )
def add_hundred(func):
def inner(*args, **kwargs):
调用原函数
r = (*args, **kwargs):
增加新功能
return r + 100
return inner
@add_hundreed
def add(a,b):
return a + b
import time
def get_time(func):
def inner(*args, **kwargs):
start_time = time.time()
fun(*args,**kwargs)
end_time = time.time()
return end_time - start_time
return inner
```
## 装饰器进阶
```
工作原理：
传参：就近原则， 从下往上
@1
@2
@3
show( )
show原——fun show————inner
show[inner]————fun2 show————inner2
show[inner2]————fun1 show————inner1
执行：按照传参的顺序倒着执行
```
## 测试
- 写出下面代码的输出并说出原因
```
list = ['a','b','c','d','e']
print(list[10::])
答：你猜，在切片那里，自己去找了输入
str1 = "hello python"
str.title( )
print(str1)
答：在字符串那里，自己去看
def text(l):
l[1] = 10
list1 = [1,2,3,4]
text(list1)
print(list1)
[1,10,3,4] 原因：是引用了转递，传递的数据是可变的数据类型，如果形参做出了修改，则实参会随着修改
def func(li = [ ]):
li.append("abc")
return li
print(func( )) ["abc"]
print(func( )) ["abc", "abc"]
情况二：
func( ) "abc"
func([1,2,3]) [1,2,3,"abc"]
func( ) ["abc","abc"]
func([1,2,3]) [1,2,3,'abc']
判断每次在操作的时候，针对的是不是同一个对象
```
## datatime
```
d1 = datetime.datetime(2020,4,3,10,10,10,100)
d2 = datetime.datetime(2020,5,3,10,10,10,100)
d11 = d1 - d2
print(d11)
print(d11.days) 获取整天数
print(d11.selonds) 获取除了整天数之外所有秒数
```
## 面向对象的讲解
- 面向对象只是一种思想，并不是一门编程语言 也不会绑定编程语言，python是一门面向语言，所有的面向对象语言的特点 封装 继承 和 多态
## 析构函数
- 将对象定义为全局变量：当程序全部执行完毕，则对象会被自动销毁
- 将对象定义为局部变量：当函数执行完毕后，则对象会被自动销毁
- 通过 del xxxx 强制删除变量： 当代码执行到 del xxxx 的时候，则对象会被强制销毁
- 析构函数的作用： 用于对象被销毁的时候程序进行清理行为，如：关闭文件，关闭数据库
## 类属性和实例属性
- 类属性和实例属性：
1. 定义的位置不同：类属性之间定义在类中，实例属性定义在构造函数中 或者动态绑定
2. 访问方式不同：类属性可以通过类名或者对象的访问，实例属性只能通过对象访问
3. 访问的优先级不同：当类属性和实例属性重名时，通过对象访问，优先访问的是实例属性
- 上面这三个必须牢记于心。 【先有类，才会有对象，对象在实例】 这里告诉我们只有找到老婆，才会有女友
4. 在内存中出现的时机不同，类属性优先级 实例属性 出现在内存中 类属性 随着类的加载而出现 实例属性随着对象的创建才会出现
5. 使用场景不同：如果是所有对象共享的数据，则定义为类属性，如果是每个对象特有的数据则定义为实例属性
```
class Animal( ):
类属性
num = 10
def __init__(self,name,age):
实例属性
self.name = name
self.age = age
print(Animal.num)
a = Animal("璐璐"，"23")
print(a.name,a.age)
```
## 类以及类中成员的定义
- 如果一个属性类属性和实例属性，被私有化则在类的外面无法通过对象属性的方式直接访问。
```
class Person( ): class Person( ):
类属性[类的定义] 限制性属性的的开头
place = " 地球 " __slots__ = ("name", " age ")
构造函数
def __init__(self,name,age):
实例属性/对象属性[对象的字段]
self.name = name
self.age = age
实例函数
def show(self):
print( f "姓名：{self.name}"，"年龄：{self.age}")
对象的创建以及类中成员的访问
类的实例外[对象的创建]
p = person("雅雅"，21)
类中成员的的访问
print(preson.place)
print(p.place)
print(p.name, p.age)
p.show
```
## 私有化的总结
### 私有函数的创建:
```
class Person( ):
def func1(self): 公开函数
print("公开函数调用了")
注意：在类内部，实例之间相互调用必须通过self函数
self.func2( )
def func2(self): 私有函数
print("私有函数调用了")
```
### 私有属性：
1. 公开属性(p u b l i c):可以在类以外的任何地方访问的属性。
2. 私有属性(p r i v a t e):只能在当前类的内部被直接访问的属性。
```
属性未被私有化
class Animal1( ):
def __init__(self,name,age):
公开属性
self.name = name
self.age = age
私有属性
self.__name = name
self.__age = age
p1 = Person
p1.func1
p1.func2
```
- 一个属性一旦被私有化，在底层形成对应的属性名，为_类名__属性名，但是不建议使用。原因👇
- python是跨平台的，私有化属性在不同的操作系统中会形成不同的形式。
- 在python为了和私有属性进行匹配对于命名有了建议
1. 被 @ property 修饰的函数名命名为私有属性的变量名如： __ name __ 。
2. @ xxx.settter 中的 xxx 必须和被 @property 修饰的函数名同名。
3. 被 @xxx.setter 修饰的函数的函数名也命名为私有属性的变量名 _name__ name
```
暴露给外界一个访问的函数
class Animal3( ):
def __init__(self,name,age):
私有属性：在属性的前面添加俩个下划线
self.__name = name
self.__age = age
定义实例函数，该函数的作用可以给私有化属性进行赋值，也可以直接获取值
获取值
@propetry 修饰的函数名相当于 get_xxx , 用于获取私有属性的值
@xxx.setter 修饰的函数相当于 set_xxx , 用于修改私有属性的值
@property property 是将一个函数转化为属性使用
def get __name(self):
return self.name
修改值
def set__name(self):
self.name = name
a1 = Animal4 ("大黄"，4)
print(a4.name) 大黄访问的是@propetty 修饰的函数
a.name = " 三 " 此处访问的是被@name.setter 修饰的函数
```
### 私有属性面试题 写出运行结果:
```visual basic
class Person( ):
@property
def show(self):
return 10
p = person( )
print(p.show) typeError: "Str"object is not callable
结论：@property 可以单独使用，并不一定能非要和@xxx.setter使用。
```
### 解释下面不同书写形式的属性和含义
```visual basic
a ： 普通属性/公开属性，在类的内部或者外部都可以直接访问。
_a : 一般被称为保护属性，在类的内部或者外部都可以直接访问，但是一般不建议使用。
__a : 私有属性，只能在类的内部被直接访问，在类的外部不可以直接访问，在类的外部一般借助于函数的访问。
__a__ : 自定义的函数不建议使用该种命名方式，一般体现为系统属性或者系统函数的命名。
```
```python
class Animal( ):
def __init__(self,name,age,height,score):
self.name = name
self._age = age
self.__height = height
self.__score__ = score
```
## 继承
- 如果俩个或者俩个以上的类，具有相同的属性和方法，我们可以抽取一个类出来，在抽取出来的类中声明各个类公共的部分
### 1.父类
```python
父类
class Person(object):
公共特征
def __init__(self,name,age):
self.name = name
self.age = age
公共的行为
def eat(self):
print("eating")
```
### 2.子类
- 当子类中未定义构造函数，则创建子类的时候会默认调用父类的构造函数，同时继承了父类中的属性和未被私有化的函数
- 当子类中定义了构造函数，但是未定义父类中的实例属性。 👇
1. 特点：默认调用子类的构造函数。
- 当子类中定义了构造函数，而且定义了父类中的实例函数。 👇
1. 特点：需要在子类的构造函数中调用父类的构造函数。
- 在子类中的构造函数调用父类中的构造函数【目的是为了定义需要的实例属性】
- 以下三点必须牢记： 👇
1. 方式一: s u p e r (当前类，s e l f ) . _init__ (参数列表)
2. 方式二: s u p e r ( ) . _init__ (参数列表)
3. 方式三: 父类列表 . _init__ (self.参数列表)
```python
class student(Person):
def __init__(self,name,age,sibject):
self.subject
def study(self):
print("studing")
w = student("雅雅"，21)
```
### 继承中的____slots____py
- 结论：在父类中定义的属性的限制绑定，无法继承到子类中如果子类需要同样的限制绑定，则需要重新定义
### 继承中的类属性
```
cloass MyClass1(object): MyClass 这是大驼峰，忘了的看上面
x = 10
cloass MyClass2(MyClass1):
pass
cloass MyClass3(MyClass1):
pass
print(MyClass1.x,MyClass2.x,MyClass3.x)
MyClass2.x = 20
print(MyClass1.x,MyClass2.x,MyClass3.x)
MyClass1.x=30
print(MyClass1.x,MyClass2.x,MyClass3.x)
```
## 封装函数的使用以及面试题
- 面向对象语言的特征是什么，怎么使用，有什么作用？ 封装， 函数，多态
### 1.封装
- 广义的封装：函数的定义和类的提取都是封装的提现。
- 狭义的封装：在面向对象的编程中，一个类的某些属性，在使用的过程中如果不希望被外界直接访问，就可以将该属性封装，将不希望被外界直接访问的属性私有化( p r i v a t e ),该属性只能被当前类持有，此时可以给外界暴露一个访问的函数。
- 封装的本质：就是属性私有化的过程。
- 封装的好处：提高了数据的安全性，提高了数据的复用性。
1. 举例:插排不需要关心属性在内部做了什么样的操作，只需要关心可以将值传进去，也可以将值获取出来。
### 2.继承
- 如果俩个或者俩个以上的类具有相同的属性和方法，我们可以抽取一个类出来，在抽取出来的类中声明各个类公共的部分。
- 当子类中未定义构造函数，则创建子类的时候会默认调用父类的构造函数，同时继承了父类中的属性和未被私有化的函数。
1. 当子类中定义了构造函数，但是未定义父类中的实例属性。
1. 特点：默认调用子类中的构造函数。
2. 当子类中定义了构造函数，而且定义了父类中的实例属性。
1. 特点：需要在子类的构造函数中调用了父类的构造函数。
3. 在子类中的构造函数调用父类的构造函数【目的是为了定义需要的实例属性】
4. 在父类中定义的属性限制绑定，无法继承到子类中，如果子类需要同样的限制绑定，则需要重新定义。
### 3.面向对象
- 面向对象只是一种思想，并不是一门编程语言 也不会绑定编程语言，python是一门面向语言，所有的面向对象语言的特点 封装 继承 和 多态
## 单列类手写@classmethod
```
class Person1(object):
per_count = 0 类属性
@classmethod
def __init__(cls):
cls.per_count += 1
cls.name = name
cls.age = age
```
## 运算符重载
- 重写：o v e r r i d e ,在继承的前提下，在子类中重新实现父类中的函数。
- 重载：o v e r l o a d, 一般是为了让一些常用的运算符支持执行的数据类型，如 _ add _ ( + ) _ lt_( < ).... 在自定义的类中重新实现指定运算对应的函数。
```
__lt__: less thon 小于 < 读法 (赖死一扣)
__gt__: greater thon 大于 > (哥瑞特赞)
__le__: less equal 小于等于 <=
__ge__: greater thon 大于等于 >=
__eq__: equal 等于 (一k油)
__ne__: not queal 不等于
```
## 抽象
- 继承基类【父类】的方法，并且做出自己的改变或者扩展代码重用。
- 由于python没有抽象类，接口的概念，所以要实现这种功能得借助于abc这个库。
- 声明某个子类兼容于某基类，定义一个接口 I n t e r f o c e 接口定义了一些接口名(就是函数名)且并未实现接口的功能：子类继承接口类，并且实现接口中的功能。
- 注意事项：
- 1. 抽象类的作用就是为了继承，抽象类就是当作父类存在的。
2. 抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化。
3. 抽象类必须继承a b c . A B C M e t a。
4. 抽象类中定义的函数【抽象函数】不需要实现
```python
import abc 抽象类
class MyClass(metaclass=abc.ABCMeta):
注意五：抽象需要被@abc.abstroctmethod
@abc.abstroctmethod
def show(self):
pass
```
- 如果一个类继承自抽象类，但是未实现抽象中的抽象方法，则该类仍然是一个抽象类，无法实例化
## 单列设计模式
- 概念：
- 什么是设计模式：
- 设计模式是经过总结：优化的，对我们经常会碰到的一些编程问题的可重用解决方案。
- 设计模式更为高级，它是一种必须在特定情形下实现的一种方法模块，设计模式不会绑定具体的编程语言。
- 23种设计模式，其中比较常用的是单列设计模式，工厂设计模式，代理模式，装饰者模式等。
- 什么是单列设计模式：
- 定义一个普通的类，该类可以创建无数个对象，定义一个类，让该类只能创建一个对象，该类被称为单列类。单列：单个实例对象。
- 程序运行过程中， 确保某一个类只有一个实例对象， 不管在哪个模块获取这个类的对象，获取到的都是同一个对象，该类有一个静态方法，向整个工程提供这个实例。
- 例如：一个国家只有一个主席，不管他在哪
- 单列设计模式的核心：一个类且仅有一个实例，并且这个实例需要应用于整个程序中，该类被称为单列类。
```
class Person(object):
__instancen = None 私有化__
def __new__(cls,*args,**kwargs):
if not cls.__instancen:
cls.__instancen = super(Person,cls).__new__
rerurn cls.__instancen
```
## with
- w i t h 是管理上下文的关键字，也被称为上下文管理器。
- 当一个对象使用with的时候：
- 当对象进入上下文的时候，会自动调用 _e n t e r _( ) 函数。
- 当对象退出上下文的时候，会自动调用_ e x i t _ ( ) 函数。
- a s：通过a s 关键字接收使用 w i t h 关键字的对象，a s 后面是一个变量名的引用，指向被打开的对象。
## csv
### 写入
```
import csv
普通
def read_csv1( ):
with open('file1.csv','r',encoding = 'utf-8')as f1:
print(f1.read())
read_csv1( )
csv
def read_csv2( ):
打开
f2 = open('file1.csv','r',encoding='utf-8')
读取
r2 = csv.reader(f2)
如果要获取读取的内存，则遍历r2
for info in r2:
print(info)
关闭
f2.close( )
```
### 写入
```
def write_csv( ):
打开
f3 = open('file2.csv','w',encoding='utf-8')
写入
获取到了一个空的可迭代对象
r3 = csv.writer(f3)
写入内容
r3.writerow("琪琪 not love ")
猜猜这是啥👇
f3.close( )
write_csv( )
```
- 注意：如果循环写入多行，则默认会在每行的后面添加一个空行，则需要设置open函数中的n e w l i n e关键字。
## 文件的基本操作
```visual basic
r 以只读方式打开文件，文件指针默认放在文件开头，文件不存在则报错
r+ 打开一个文件用于读写，文件指针默认放在文件开头，文件不存在则报错
w 打开一个文件只用于写入，如果该文件已存在则将其覆盖，如果不存在，创建新文件
w+ 打开一个文件用于写读，如果该文件以存在则将其覆盖，如果不存在，创建新文件
a 打开一个文件用于追加，如果文件已存在，文件指针会放在文件结尾(也就是说，新的内容会被写到已有内容之后)如果不存在，创建新文件进行写入a+ 打开一个文件用于写读，如果文件以存在，文件指针会放在文件结尾，文件打开时会是追加模式，如果不存在，创建新文件用于写读
其他模式:rb rb+ wb wb+ ab ab+
```
## 常见的异常
- AttributeError 试图访问一个对象没有的树形，比如：f oo.x 但是f o o没有属性x
- IoError 输入/输出异常，基本上是无法打开文件。
- ImPortError 无法引入模块或包，基本上是路径问题或名称错误。
- IndentationError 语法错误(的子类)，代码没有正确对齐。
- IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]。
- KeyError 试图访问字典里不存在的键。
- KeyboardInterrupt crtl + c 被按下
- NameErrot 使用一个还未被赋于对象的变量。
- SyntaxError python代码非法，代码不能编译(个人认为这是语法错误，写错了)阳姐讲的。
- Type Error 传入对象类型与要求的不符合。
- UnbaundLocalError 试图访问一个还未被设置的局部变量基本上是由于另有一个同名的全局变量，导致你一万正在访问它。
- ValueError 传入一个调用者不期望的值，即使值的类型是正确的。
## 阳姐的浓缩精华
- NameError 当使用了一个未定义的变量。
- ValueError 传入一个不期望的值，即使类型是正确的。
- TypeError 传入的数据类型不匹配。
- IndexError 当列表，元组或者字符串的索引越界。
- AttributeError 当一个对象访问了不存在的属性或者函数。
- UnboundLocalError 修改了其他作用域的变量：在函数内部修改了全局变量或者作用域中修改了函数作用域中的变量。
- nonlocal 阳官方没有讲解，朕也不懂。自己查去。
- FileNotFoundError 当读取文件的时候，文件不存在。
- MoudleNotFoundError 模块导入错误，主要模块的路径有问题。
- ImportError
- SyntsaxError python代码非法，基本的语法错误。
## try except finolly
- 函数结束之前finally都会被执行
```
在函数中使用 try - except -finolly 语句，如果出现return。
def test( ):
try:
numlist = [34, 5, 3]
index = int(input("请输入数字： "))
num = numlist[index]
return
print(num)
except valueError as e:
print(e)
finally:
print("被执行了")
```
## assert 表示断言也可以说预测
```
def div(x,y):
assert y != 0, "在除法运算中，除数不能为0"
r = x / y
return
print(div(10,2))
print(div(10,0))
```
## 自定义异常
```
class MyExcption(BaseException):
定义构造函数在其中定义实例属性，该实例属性表示信息描述
def __init__(self,message):
调用异常父类的构造函数
super( ).__init__( ) 👈这个东西上面也有总结，忘记可以上去看
self.message = message
重写 __str__,返回异常信息描述
def __str__(self):
return self.message
定义一个实例属性，用于解决问题。
def handle(self):
print("解决了")
e = MyExcpetion("出现了异常")
print(e)
try:
raise MyExcpetion("出现了异常") 方法2
except MyExcption as e:
print(e)
e.handle( )
```
## 正则常用函数
```
print(re.splist(r"a",'1A2a3a4A5a',re.I))
结果为： 1A2, 3 4A5a
print(re.splist(r"a",'1A2a3a4A5a',flags = re.I))
结果为： 1, 2, 3, 4, 5, " "
```
## 进程的特点
- 独立性：不同的进程之间是独立的，相互之间资源不共享。
- 动态性：进程在系统中不是静止不动的，而是系统中一直活动着。
- 并发性：多个进程可以在单个处理器上同时进行且互不影响。
- 多进程：一个操作系统可以运行多个应用程序。
- 线程：
- 是进程的组成部分，一个进程可以有多个线程，每个线程处理一个特定的子任务。
### 进程和线程之间的关系
- 一个程序运行后至少有一个进程。
- 一个进程可以包含多个线程，但是至少有一个线程，否则这个进程没有意义的
- 进程间不能共享资源，但进程之间可以的。
- 系统创建进程需要为该进程重新分配系统资源，而创建线程则容易的多，因此使用线程实现多任务并发比多进程的效率高。
### 前面编写的所有python程序，都是执行单任务的进程，也就只有一个线程，如果我们要执行多个任务怎么办？
- 多进程模式：启动多个进程，每个进程，虽然只有一个线程，但多个进程可以一块执行多个任务。
- 多线程模式：启动一个进程，在一个进程内启动多个线程，这样多个线程也可以一块执行多个任务。
- 协程模式：启动一个进程，启动一个线程，但是借助于函数生成器[yield]可以执行多个子任务。
- 多进程加多线程模式：启动多个进程，每个进程在启动多个线程，这样同时执行的任务就更多了。
- python支持多进程，又支持多个线程。朕的个人理解，学一个东西，我们就要认为这东西美好，要多夸它，使它彻底插根在你心里。
## 网络编程基础
- 计算机之间需要通信的必要条件是什么？分别有什么用？
- 必要条件： ip地址 端口 网络协议
1. ip地址指的是互联网协议地址，是联网设备和互联网之间唯一的标识，在同一个网段中，ip地址是唯一的。
2. 数据的发送与接收都需要通过端口出入计算机，端口号用于唯一标识通信实体上进行了网络通讯的程序同一台机器上不能俩个程序占用同一个端口。
3. 只要遵守了网络协议，任何私有网络，只要支持指定的协议就可以联入互联网。
## Tcp编程
简述Tcp和UDp之间的区别
Tcp的特点：
- 安全的(确保接收方完全正确地获取发送所发送的全部数据)。
- 面向连接的(面向连接的协议，数据传输必须要建立连接所以在Tcp中需要连接时间)。
- 数据传输的效率较低。
- 传输数据大小限制，一旦连接建立，双方可以按统一的格式传输大的数据。
udp特点：
- 不安全，发送方法所发送的数据报并不一定以相同的次序到达接收方，Udp就是将数据包发送给对方，对方不一定能接收到，比如：飞秋
- 无连接，每个数据报中都给出了完整的地址信息，因此无需建立发送方和接收方的连接。
- 效率高，速度快。
- Udp传输数据时时有大小限制的，每个被传输的数据报必须定在64kb之内。
## 使用经典的三次握手建立连接
- 客户端向服务端发送一个请求。
- 服务端收到请求后，回客户端一个响应。
- 客户端向收到服务的响应后，回服务端一个确认信息。
## Python基础总结
> 一、变量和运算符
>
> 变量的定义
>
> 常用的运算符：算术，赋值，关系，逻辑，成员，三目
>
> 二、语句
>
> if语句，while语句【while True】，for语句
>
> 三、函数
>
> 函数的定义：参数，返回值
>
> 匿名函数
>
> 变量的作用域：全局，函数，局部
>
> 装饰器：闭包，装饰器的使用
>
> 高阶函数：map\reduce\filter\sorted
>
> 递归函数
>
> 四、模块
>
> 自定义模块：import xxxxx / from xxx import xxx
>
> 系统模块:time,os,math,random
>
> 第三方模块
>
> 五、面向对象
>
> 继承，封装，多态
>
> 类的定义和对象的创建
>
> 类中特殊的属性和函数
>
> 单例设计模式
>
> 六、文件操作
>
> 普通文件、二进制文件，csv文件，对象的序列化和反序列化
>
> 七、正则表达式
>
> 八、进程和线程
>
> 九、网络编程
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
