Python 学习

如何安装Python?

去Python官网下载安装包

在安装过程中第一步需要在安装页面选择添加环境变量add Python 3.7 to PATH

安装完成之后，需要在cmd 输入python 查看python的版本号

用什么软件编写Python？

常用的有Pycharm 、Eclipse 、 VS code

基础知识

1、数据类型：

整数：可以为任意大小、包含负数

浮点数：小数

字符串：以单引号、双引号、三引号括起来的文本

布尔：只有两种True 和Flase

空值：None表示

变量：用于保存数据

• 见名知意
• 变量名是由英文字母，数字和下划线
• 不能以数字开头
• 举例 ：

name = input ('键盘输入')
print  (name)

扩展：

python为引用变量，存放的是地址，计算机会根据此地址查找对象的值

常量：不可变的量

扩展：python 解释器有；CPython，Jython,IronPython,pyPy....

2、注释

单行注释：# 这是一个注释

多行注释：''' 这是多行注释 '''

3、转义字符

转义符是为了让计算器识别字符串，例如英文的I‘m love you 在计算器输出中时，他会判断字符串，因为出现三个单引号，他识别失败，而转义符就是解决这种问题，当在I'\m love you 在输出时，他就不会讲单引号识别成单个字符串，把这个单引号当成整体内容。

\例子和\

s = "使用\"创建字符串"
print(s)
---使用"创建字符串

a = "亲爱的宝宝们" \
    "我爱你们"
print(a)
--亲爱的宝宝们我爱你们
# 在字符串行尾的续行符，即一行未完，转到下一行继续写，使其作为完整的一行内容来输出

\n : 表示换行 换行输出 print('1234\n56789')

\t：表示制表 四个空格即两个tab print('1234\t56789')

r：取消转义字符

当打印输出有多个\\\ 这种情况如目录 需要使用 r 去掉转义字符

扩展

4、占位符

%s : 表示字符串 print('我叫%s，今年%s岁' % (name, age))

%d ; 整数 print('我叫%s，今年%s岁' % (name, 20)) 当在%之后加上数字，意味着这里需要留出相对应空位

%f : 浮点数 print('圆周率=%.6f' % 3.1415926)

​ 在%之后加.输入位数即精确到小数点后几位

input() : 获取用户输入即键盘输入

强制转化：将一个字符串转化成其他类型

int() 将字符串类型数组转换为整数 print('我叫%s，今年%d岁' % (name, int(age)))

print('我叫%s，今年%d岁' % (name, int(age)))  # int()将字符串类型数字转换位整数
print('我叫%s，今年%3d岁' % (name, int(age)))  # % ---我叫lll，今年 18岁
print('圆周率=%f' % 3.1415926)  # %
print('圆周率=%.6f' % 3.1415926)  # %

5、字符编码

计算机需要通电工作，电的特性是高低电平，人门从逻辑上讲二进制数对应高低电平，机器也是是识别高低电平，也就是说机器只认识数字。在日常生活中，我们都是用人类能懂得字符交流，为了让机器也识别人类的字符，也就是说，需要计算机翻译人类的字符。

总结就是，字符编码就是讲人类的字符编码成计算机能识别的数字，而这有一套固定的标准。称为字符编码。

ASCII美国人指定的，规定英文字母数字和一些特殊字符与数字对应关系。最多有8位(8位8个二进制)，即2**8=256。

GBK

Unicone - 2byte 内存

utf-8 1~4byte 硬盘

7、打印格式化输出

举例：

name = input('请输入您的姓名：')
age = input('请输入年龄：')
# 我叫xxx，今年xx岁
print('我叫' + name + '，今年' + age + '岁')

print('我叫%s，今年%s岁' % (name, age))

print(f'我叫{name}，今年{age}岁')

第二和第三在python常用，使用第一种也可以，但是太过于复杂。第二种和第三种记住就可以。

8、运算符

算术运算符

比较运算符

赋值运算符 =

a = 10
c = a + 1
print(c)

逻辑运算符

9、列表与元组与字典

列表 [ ]：list

python最常用的数据类型，list

列表  [元素1，元素2，元素3]

元素  列表中保存的数据称为元素
元素  元素之间用逗号隔开
列表中的元素是有序的，元素的下标-index,下标从0开始
列表中可以存整数，浮点数，字符串，布尔值

正索引：从0开始

values: 代表元素

indexs: 索引也称为下标

负索引/反向索引：下标从尾部开始，从-1开始

列表操作符：

常用函数方法：

获取元素长度len(变量)函数：

# 获取元素个数
print('---获取元素个数')
lenth = len(name3)
print(lenth)
print('-----获取元素长度')
print(len(name4))

# 获取最后一个元素
print('---获取最后一个元素')
print(name3[lenth - 1])

函数扩展：

追加元素到列表末尾和：

name3.append('新疆')  # 追加元素到列表的末尾
print(name3)
print(name3.append('肖黄'))
print(name3)

追加元素到指定位置insert(索引，‘值’)

name3.insert(0, '成都')  # 追加元素到指定位置下标
print(name3)

删除元素用索引pop() 默认删除最后一个:

name5 = name3.pop(5)  # 删除按下标删除，并返回指定元素
print(name3)
print(name5)
print(name3.pop(2))
print(name3)
print('----------')
# name.pop() 默认删除最后一个
print('--默认删除最后一个元素打印输出')
print(name3.pop())

清空列表clear()：

print(name3.clear())

删除元素用元素remove():

print('---删除指定元素')
print(name3.remove('深圳'))
print(name3)

修改元素 根据index修改：

index = name3.index('北京')  # 使用index获取值
name3[index] = '地狱'
print(name3)
print('---修改指定元素')
name3[1] = '天堂' # 修改指定元素按照索引修改
print(name3)

空列表：

空列表也是有意义的，当我们需要存放一些变量是可用列表存放

a = []

二维列表和多维列表：

二维列表也就是在一维列表中添加了新的列表。多维亦是如此。

b = [1,2,3,[4,5,6]]
print(b[1])
print(b[3])

查询二维列表的值

# 取二维列表，先取二维数组的下标，然后在取二维列表中的下标
print(b[3][1])

注意：当下标越界或者是索引越界就会出现异常

lsit index out of range 下标越界错误

元组()

元组与列表类似，不同之处在于处在元组下的元素不能修改。

# 元组中只有一个元素时，必须补一个逗号
a = (1,)
print(a)

# 空元组
c = ()
print(c)

元组和列表一样，也是个序列，与列表不同元组是不可变的，只能查询元素，增删改元素都不允许

# 元组中只有一个元素时，必须补一个逗号
a = (1,)
print(a)

# 空元组
c = ()
print(c)

列表与元组转换list 和 tuple

# 列表和元组进行转换
# list 元组转列表   将一个序列变成列表
print('---list 将一个序列变成列表')
print(list(address))

# tuple 列表转换元组  讲一个序列转化成元组
print('---tuple 列表转换元组')
score = [90, 18, 85, 46, 89, 100]
print(tuple(score))

字典 dict

字典能够更加精确的存储数据，以键值对的形式存储。

• 字典中每个key对应一个值，key是不可变化的
• 字典中的数据是无序的
• key，是唯一的，value是可变的
• 字典的查询特别快
• 字典是以空间换时间，会浪费内存

与列表类似有一样的方法

# 字典
classmates = {'王海':90, '骆纯':80, '李宁':70, '赵艳芳':88, '任收港':98, '李颖':85, '王珍':87}

print(classmates)
# 添加元素
classmates['张玮越'] = 83
print(classmates)
# 删除元素
classmates.pop('李宁')
print(classmates)
# 修改值
classmates['张玮越'] = 89
print(classmates)
# 查询
score = classmates.get('赵艳芳')
print(score)
# 计算字典元素个数
print(len(students))
# 清除所有元素
print(student.clear())
# 返回字典中所有的元素的主键key
print(students.keys())
# 返回字典中所有的元素的值value
print(students.values())
# 返回以列表返回可遍历的(键, 值) 元组数组
print(students.items())

print('--for循环遍历字典--')
# 循环遍历key
for i in students:
    print(i,students.get(i))
# 遍历value
for value in students.values():
    print(value)
# 遍历key,value
for key , value in students.items():
    print(key,value)

set集合

• 也是一组key的集合
• setj集合也是无序的
• set中的元素是不可重复的
• set集合可以用来去重和关系运算
• 使用{}大括号/花括号，只能存储不可变类型

扩展：

查看可变数据类型和不可变数据类型

不可变数据类型更改后地址发生改变，可变数据类型更改地址不发生改变

• 不可变数据类型： 当该数据类型的对应变量的值发生了改变，那么它对应的内存地址也会发生改变，对于这种数据类型，就称不可变数据类型。

• 可变数据类型 ：当该数据类型的对应变量的值发生了改变，那么它对应的内存地址不发生改变，对于这种数据类型，就称可变数据类型

• 数据类型	可变/不可变
  整型	不可变
  字符串	不可变
  元组	不可变
  列表	可变
  集合	可变
  字典	可变

• 可以使用id()方法查看

10、分支结构

首先讲下python的流程控制

分三种：

• 顺序结构：从上到下执行
• 分支结构：根据条件选择执行某段代码，实现分支只有一种if
• 循环结构：让代码重复执行，在python中，有两种for、while两种方式

1. if单分支结构：

   if单分支结构-满足某个条件就执行某个操作，不满足就不执行

   # 语法 ：
   # if 条件语句：
   #    代码块
   age = int(input('请输入您的你年龄:'))
   if age <= 18:
       # 缩进-indent
       print('未成年')

   条件语句可以是任何有结果的表达式，比如：独立的数据、运算表达式(不能是赋值运算)、函数调用表达式

   ：固定写法

   代码块和if 保持一个缩进的一条或者多条语句；满足条件才会执行的语句

   执行过程：先判断条件语句是否是true(若果不是布尔值，就转化为布尔值再判断)，如果为true就执行if语句的代码块，否则不执行

2. if双分支结构

   age = int(input('请输入您的你年龄:'))
   if age <= 18:
       # 缩进-indent
       print('未成年')
   else: # 无条件执行
       print('成年人')  # else可以有，可以没有，但是最多有一个,

3. if多分支

   weight = float(input('请输入您的体重(kg):'))
   height = float(input('请输入您的身高(m):'))
   # 计算bmi
   bmi = weight/height**2
   print('您的bmi指数是%.1f'%bmi)
   if bmi<18.5:
       print('太瘦')
   elif bmi<25:
       print('正常')
   elif bmi<28:
       print('微胖')
   elif bmi<32:
       print('肥胖')
   else:
       print('死肥宅')

   多分支，即有多个选择判断，使用elif 条件语句：，最后面的else 可有可无。

11、循环结构

循环示意图：

for 循环

又称：循环 迭代，遍历

遍历操作，以此从集合容器中取每个值

循环格式：

# for 临时变量 in 字符串，列表等：
#     执行代码块

举例

# 求100之内数和
sum = 0  # 定一个初始变量 ，用于存放累加和
for data in range(1,101):   # 使用range函数创建一个顺序的集合，range(1,101)1代表从1开始，101代表索引即下标为101的元素，代表是100这个元素
    sum = sum + data  # 每次累加，
print(f'--{sum}')  # 打印输出

# 输出100以内的偶数和奇数
for i in range(1, 101):  
    if i % 2 == 0:         # 判断是否能被2整除，即为偶数
        print(f'是偶数{i}')
    else:                  # 其他就是奇数
        print(f'是奇数{i}')

案例----登录判断用户和密码，限定用户输入次数。for 与else 联合使用

'''
 案例，限定用户登陆的次数，一旦三次没有登录成功就提示用户已被锁定
 思路：  用for循环控制尝试登陆的次数，执行完整个for循环没有登录成功则锁定账户
 所采用的结构：
 for 变量 in 遍历对象：
    执行代码块
 else:
    循环执行结束后,要执行的内容
'''
username = 'admin'
userpassword = '123456'
for i in range(1, 4):
    a = input('请输入用户名：')
    b = input('请输入密码：')
    if a == username and b == userpassword:  # 与默认值对比，正确登陆成功，跳出循环，反之继续循环直至结束
        print(f'欢迎{a}登录成功')
        break
    else:  # 反之提示输入错误，
        print(f'密码或账户错误，失败请重新输入')  # 循环直至循环结结束
else:  # 在循环中使用else 即当循环结束，打印输出以下语句
    print('密码或者账户输入错误三次，账户已锁定，请联系管理员')

注意：只要循环语句中break语句没有执行，else就会执行 ，也是break与else使用。

while 循环

重复执行某一段代码，当达到循环条件时，结束循环。

格式：

# 1. 设置循环结束条件
# 2. 书写循环条件判断条件
while 判断条件:
# 3. 需要重复执行的代码
# 4. 改变循环的初始条件(计数器)
# 1. while 是关键字

举例：

'''
while循环
'''
s = 0
i = 1
while i<=10: # 只要条件满足，就执行循环体
    s = s + i
    i = i + 1
print(s,i)

for循环与while循环区别

• for循环已知循环次数，
• while循环不知道循环的次数，只有循环条件

break：跳出循环，执行循环之外的语句

for i in range(1,11):  # 定义一个集合
    if i ==4:          # 判断当i =4 跳出循环
        break
    print(i)           # 此时还在for中执行打印输出循环次数

continue：跳过本次循环，继续下次循环

for i in range(1, 11):
    if i == 5:
        continue      # 跳过此次循环，不计入打印
    print(i)

12、函数

简单讲就是讲代码封装起来，方便使用，函数就是‘洗衣机’ , 定义函数就是‘准备装洗衣机’ , 调用就是 ‘ 用洗衣机 ’, 函数注释就是 ‘ 洗衣机说明书 ’ , return 返回值就是 ‘ 拿出洗完的衣服 ’。

语法格式：

# def 函数名(参数名1, 参数名2) :
# ''' 函数注释 '''
# 函数体代码
# return 返回值

• 函数的定义
  • 函数必须先定义后调用
  • 函数在定义阶段只检测语法不执行语法，简单讲就是自检，不执行输出
  • 函数只有在调用阶段才会执行函数体代码
• 函数调用
  • 函数名加括号
  • 定义时有参数，需要传参

图了解函数

函数的分类：

内置函数

• python解释器自带的函数

自定义函数

• 有参函数
• 无参函数
• 空函数

注意：

• 函数一定要有返回值，如果不显示指明返回值，则默认返回None
• return语句只能返回一个值，如果试图返回多个值，会自动打包成一个元组

函数参数详解

'''
位置参数：positional argument
        -必须传参
        -传入的实参按照顺序(位置)传递给形参， 不能多，不能少

默认参数: default parameter
        -有默认值的参数
        -可以极大的降低调用函数的难度
        -默认参数必须放在位置参数的后面
        -默认参数可以按照顺序传参， 但如果不按照顺序传参，则必须指明参数名称

可变参数：
        -实参的多少不固定，形参前面有一个*， 星号的作用是将传入的所有实参封装为一个元组
        *在实参的前面表示拆包，*在形参的前面表示打包
        -可变参数允许传入0个或多个实参
        -一个函数中最多有一个可变参数，也可以没有

关键字参数：keyword arguments
        -形参的前面有2个星号： **， 将传入的所有参数封装为一个字典
        -关键字参数允许传入0个或多个包含参数名的参数
        -可以扩展函数的功能
        -一个函数中最多有一个关键字参数，也可以没有

命名关键字参数：keyword-only argument
        -命名关键字参数必须写在 一个单独的 * 号的后面
        -命名关键字参数如果放在可变参数的后面，可以省略 *
        -命名关键字参数必须给值，除非已经有默认值了

'''

位置参数：

# 一个参数  求数的平方
def sss(x):
    return x * x


print(sss(10))
print('------')

# 两个参数 求数任意次方
def ddd(x, y):
    return x ** y


print(ddd(10, 20))

默认参数：

def sqere(x, y=2):
    return x + y


# 因为有默认的值，在传参数的时候，可以直接使用默认的
print(sqere(10))
# 也可以同时传参，将默认的值替换了
print(sqere(10, 3))

可变参数：

def sum(*data):
    print(data)
    s = 0
    for i in data:
        s = s + i
    return s


# 直接将多参数传给函数
r = sum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(f'r={r}')
# 定义一个列表存放传参
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 与函数中参数要相同
r = sum(*data)
print(f'r={r}')

关键字参数：

def info(name, age, gender='男', city='西安', **kw):
    print(name, age, gender, city, kw)

info('tom', 20, '男', '北京')
info('tom', 20, '男', '北京', marrige='否', car='BBA', house='200')

命名关键字参数：

def info(name, age, gender='男', city='西安', *, hobby, education='本科'):
    print(name, age, gender, city, hobby, education)
# info('tom', 20, '男', '北京', marrige='否', car='BBA', house='200')
info('tom', 20, '男', '北京', hobby='游戏', education='本科')
info('tom', 20, '男', '北京', hobby='游戏')

多种参数同时使用：

def funtion(a,b,c=2,d='tom',*e, f,g,**h):
    print(a,b,c,d,e,f,g,h)
# 分析，a,b，为位置参数，c为默认参数，形参中*e代表可变参数，形参**h为关键字参数
funtion(1,20,3,'mike',3,6,9,f=100, g=200, marrige='否', car='BBA', house='200')

def funtion(*args, **kw):
    print(args, kw)
# 前面到9，都是可变参数，因为后面是直接定义参数赋值，归到命名关键字参数
funtion(1,20,3,'mike',3,6,9,f=100, g=200, marrige='否', car='BBA', house='200')

13、递归函数

函数在运行过程中，直接和间接调用自身

特点：

• 必须有一个结束条件
• 每一次递归都必须离结果更进一步
• 通常前一次的输出作为下一次输入
• 没有结束条件，递归次数过多导出内存溢出，即报错

'''
5! = 5*4*3*2*1 = 5*4! = 5*(5-1)!
4! = 4*3!
3！= 3*2！
2！= 2*1！
1！= 1

'''


# 得出规律 n! = n* (n-1)!

def f(n):  # 定义函数
    if n == 1:  # 结束条件-边界值条件
        return 1
    return n * f(n - 1)  # 返回值对自身调用


print(f(5))

14、变量

全局变量

• 整个模块

局部变量

• 定义变量的函数或方法

成员变量/实例变量

• 定义变量的实例中：构造方法__init__()中定义的,通过 self 参数引用;

类变量

• 定义变量的类中，在对象/类中，不在对象/类的函数中

总结：Python中变量的区别就是作用域不同，作用域越小的变量，优先级越高

# 局部变量和全局变量
#	python中数据有类型，变量没有
#	变量之间唯一区别就是变量的作用域不同
#		全局变量-作用域是整个模块
#		局部变量-作用域在定义函数之中
#   局部变量的优先级高于全部变量 
#	优先使用局部变量，一般不要使用全局变量
#成员变量/实例变量
#	作用域在定义变量的实例中
#类变量
#	定义变量的类中
a = 10  # 全局变量 - 作用域是整个模块
print(a)

def f(x):
    b = "5" # 局部变量 - 作用域是在定义它的函数之中- 局部变量的优先级高于全局变量
    print(b)
    global a # 声明a是一个全局变量
    a = 8
    print(f'a1={a}')

f(4)
# print(b)
def m():
    b = 9
    print(f'a2={a}')

m()

class F():
    clazz = 56 # 类变量
    def __init__(self, v3)
    v1 = 10 # 局部变量
    self.v3 = v3 # 成员变量/实例变量

15、列表/元组/字符串切片---[:]

切片顾名思义及把列表切开分成不同的部分

注意：

• 切片操作产生一个新的列表
• 切片操作可以用于列表、元组、字符串

'''
切片
    切片操作产生一个新的列表
    因为切片操作适用于列表，元组，字符串
'''

names = ['王海', '骆纯', '李宁', '赵艳芳', '任收港', '李颖']

m = [names[0], names[1], names[2]]
print(m)
m = names[1:3] # 包含前面的索引，不不包含后面的索引
print(m)
m = names[2:] # 截取到末尾
print(m)
m = names[:4] # 从头开始截取
print(m)
m = names[:] # 复制列表
print(m)
print(id(m))
print(id(names))
# id()查看内存地址
n = names
print(n.pop())
print(id(n))
print(id(names))

o = names[::2] # 步长默认是1，也就是说：：后面接步长
print(o)

16、列表/元组/字典生成式

t2 = (i for i in range(100))  # 元组()
print(t2)  # 此时打印的这个对象的地址
print(tuple(t2))  # 将对象转化为元组
# 列表和字典无需转化
t3 = [i for i in range(10)]  # 创建一个列表 []
print(t3)
t4 = {i for i in range(100)}  # 字典表达式 {}
print(t4)

生成式：元组特殊需要对其tuple转化，其余[列表]和{字典}

17、装饰器

​ 在不改变函数原有代码的情况下，增强函数的功能

​ 装饰器本质上是一个高阶函数

'''
装饰器
	作用：
    在不改变函数原有代码的情况下，增强函数的功能
    原理：
    装饰器本质上是一个高阶函数，传入一个函数作为参数，然后返回一个新的函数
'''

import time


def log(func):  #
    def wrapper(*args, **kw):
        print(f'正在执行函数{func.__name__}:')
        return func(*args, **kw)

    return wrapper


def service(func):
    print(f'正在执行函数{func.__name__}:')


@log  # now = log(now)  # 调用这个函数@函数名
def now():
    # print(f'正在执行函数-{now.__name__}:')
    # service(now)
    print(time.strftime('%Y/%m/%d %H:%M:%S'))


now()


def f():
    print(f'正在执行函数{f.__name__}:')
    # service(f)
    pass


# 此处是直接调用函数中的函数
# f = log(f)


@log  # g=log(g)
def g():
    # print(f'正在执行函数{g.__name__}:')
    # service(g)
    pass


f()
g()

对于修饰器来讲最主要的是会调用，及@函数名，与运行函数的调用。

18、高阶函数

• 函数名就是一个变量，这个变量指向了函数对象本身
  • 如果一个函数f接收了另一个函数g作为参数，那么我们就把函数f称为-高阶函数
  • 如果一个函数f返回了另一个函数g作为返回值，那么我们就把函数f称为-高阶函数
• 闭包：内部函数引用外部函数

def g(x):  # 参数函数
    return x * x

x = 3

# 函数作为参数
def f(x, g):  # g代表上面的函数
    return g(x) + g(x)

print(f(x, abs))
print(f(-3, abs))
print(f(-3, g))

# 函数作为返回值
def sum(*args):
    def ss():
        s = 0
        for i in args:
            s = s + i
        return s
    return ss  # 返回值为函数

r = sum(1, 4, 7, 9, 10, 22)
print(f'r={r}')  # 打印功能地址
print(f'r={r()}')  # 调用函数输出

19、匿名函数

匿名函数及lambda表达式，

• 匿名函数及没有名字，
• 通常用于判断或者计算
• 函数的输入值为参数，输出值由表达式计算出来

# 匿名函数-lambda表达式,默认有一个return,将表达式的结果返回
r = map(lambda x:x*x,[1,2,3,4,5]) # 匿名函数求列表阶乘
print(list(r))  # 将map转化list 

ff = lambda x:x*x
print(ff(4))
# 举例
print('---利用map函数将字符串首字母变为大写,其余字母小写(使用lambda表达式)---')
a = ['tom', 'MIKE', 'Tony']
# 定义一个变量，先将列表转化为map函数，在使用匿名函数，
# 对列表中元素操作调用map函数的方法capitalize首字母大写，最后对结果强制转为list
# lamba函数格式：lamba  变量：操作 ，变量

list_name = list(map(lambda a: a.capitalize(), a))
print(list_name) 

# s:s[0]获取下标为0的元素，调用函数upper转化大写，+ 拼接字符串s[1:]从下标为1开始直至结束，使用函数lower()转化为小写，m代表
list1 = map(lambda a: a[0].upper() + a[1:].lower(), a)
print(list(list1))

20、模块

模块
一个.py文件就是一个模块(module)
-提高代码的可维护性
-方便代码复用
-避免函数名和变量名冲突

包
一个包含__init__.py模块的文件夹就是一个包(package)
-避免模块名冲突
-方便代码管理

# 自定义模块
# import demo19_装饰器
from demo19_装饰器 import log
from ppp.demo import ddd

# 系统模块
import time
import sys


# 第三方模块
# pip config set global.index-url https://mirrors.aliyun.com/pypi/simple/ - 设置镜像
# pip list - 查看已安装模块
# pip install requests - 安装模块
# pip uninstall requests - 卸载模块

21、面向对象编程

面向对象编程

面向过程，函数是核心

面向对象

Class：类

​ 类名首字母一般大写

​ 写的类都是自定义类型

object：(对象)object是所有类的父类，默认继承object，可以省略不写

self.name 成员变量

面向对象编程三大特点

1. 封装：将数据和处理数据的方法都封装在对象中
2. 继承：当我们定义一个类的时候，都可以从某个现有的类继承，新的类称为子类(Subclass)，
   被继承的类称为父类(基类，超类SuperClass)，通过继承，子类可以获取父类的全部功能
3. 多态：一个对象既是子类的实例，也是父类的实例

class Person:  # 创建父类
    def __init__(self, name, age):  # 定义成员变量
        self.name = name
        self.age = age

    def talk(self):  # 定义成员方法
        print(f'{self.name}正在大声的说废话...')
class Worker(Person):  # 继承

    def __init__(self, name, age, position):  # 成员变量
        super().__init__(name, age)  # 调用父类的初始化方法
        self.position = position  # 创建子类独有的成员变量
    # 方法重写-子类和父类存在同名方法时，子类的方法会覆盖父类的方法
    def talk(self):
        # super().talk()
        print(f'{self.position}{self.name}正在大声的讨论技术...')
# 实例化
#     创建某一个类的具体的一个对象的过程，称为实例化instanciate，
#     创建出来的对象也称为实例instance
# w = Worker('jonny', 30)
w = Worker('jonny', 30, '高工')  # 创建工人对象实例
w.talk()  # 调用子类重写父类的方法

22、异常处理

• try：
  • 可能出问题的代码，必须要有，但是只能有一个
• except：
  • 捕捉异常，发生异常时才执行，可以有，也可以没有，也可以最多有一个
  • 当多个except语句时，小类型一定要放在大类型的前面
• finally
  • 一定要执行的代码放在这里，可以有，也可以没有，但是最多有一个
• breakpoint：断点

try:
    n = int(input('请输入一个整数：'))
    a = 0
    print(n,a)
    r = n/a
    print(f'r={r}')
# except ZeroDivisionError as e: # 捕捉异常
#     print(f'ZeroDivisionError:{e}')
# except TypeError as e:
#     print(f'TypeError:{e}')
# except Exception as e:
#     print(f'Exception:{e}')
finally:
    print('--OVER--')

print('--搞定收工--')

23、IO流

Input/Output

​ 读(输入)：从硬盘到内存

​ 写(输出)：从内存到硬盘

读文件：

• r：read
• encoding：编码方式，默认是gbk

对文件或者其他类型的文件时，都需要异常的处理，在对于文件操作时，使用以下格式

with open(r'.\demo.txt', 'r', encoding='utf-8') as f:
    # read:读取文件的全部内容
    # read(n): 读取指定个数的字符
    # readline: 按行读取
    # readlines(): 读取所有的行
    r = f.readlines()
    print(r)

'''
写文件
    写的时候，如果文件不存在，则会创建一个新文件
    w: write,覆盖写
    a: append，追加写
'''
with open('demo.txt', 'a', encoding='utf-8') as f:
    f.write('\n上海疫情失控。')
'''
    : binary 二进制
'''
with open('demo.txt', 'wb') as f:
    r = f.read()
    print(r)
with open(r'D:\workspase\20190115-5.jpg', 'rb') as d:
    # 打开被复制的图片，需要rb
    # 读取图片
    data = d.read()
    print(data)
    # 关闭
    d.close()
with open(r'.\20220407.jpg', 'wb') as s:
    new_data = s.write(data)
    s.close()

24、字符串

'''
字符串
'''
import re

# 字符串切片
s = 'abcdefg'
print(s[:3])  # 切到 d(不包含d) 使用下标
index = s.index('d')  # 切到 d(不包含d) 指定元素
print(s[:index])

s = ' tom, mike, jerry\n '
'''
split:
    按照指定字符进行切分，并将切分的结果以列表的形式返回
strip:
    去除字符串前后多余的空白字符
'''
# r = s.split(',', 1)
r = s.split(',')
print(r)
# 遍历元素按，分割字符串，去掉空白字符
r = [i.strip() for i in r]
# 列表生成式
r = [i.strip() for i in s.split(',')]
print(r)

a = ' abc\n '
print(a)
print(a.strip())

'''
正则表达式
'''
# 因为有边界值，当前面有空格，会选择一个空格
r = re.split(r'\s+', s)
print(r)

25、连接数据库数据库操作

1. 导入数据包，import mysql.connector
2. 连接数据库：
3. 获取游标(操作数据的对象)：cursor = db.cursor()
4. 操作数据：cursor.execute('sql操作语句')
5. 提交事务：mysqldb.commit()
6. 关闭连接：mysqldb.close

# 连接数据库
db = mysql.connector.connect(host='localhost',
                             port=3306,
                             user='root',
                             password='123456',
                             database='demo')  # 指定数据库
# 创建游标
cursor = mysqldb.cursor()
# 操作数据
# 	创建数据库
cursor.execute('CREATE DATABASE demo CHARACTER SET "utf8";')
# 更新数据
cursor.execute("UPDATE USER SET age = %s WHERE id =%s;",(age,id))
# 提交事务
'''事务
    将一系列可以看做一个整体的操作称为一个事务
    提交commit  - 如果事务执行成功，则提交，让改动永久生效
    回滚rollback- 如果事务执行失败，则回滚，撤销之前的操作
A 原子性
C 一致性
I 隔离性
D 持久性
'''
mysqldb.commit()
# 关闭连接
mysqldb.close
# 查询数据
cursor.execute('select * from user')

# 获取查询的结果
result = cursor.fetchall()  # 查询使用游标的fetchall方法，查询结果为一个列表包含元组
print(result)

ORM对象关系映射

将数据的数据映射到代码对象中，主要为了查询结果

# 获取查询的结果
result = cursor.fetchall()
# 创建对象
class User: 

    def __init__(self, id, name, age):
        self.id = id
        self.name = name
        self.age = age
# 将查询结果给他对象实例化
user1 = User(result[0][0],result[0][1],result[0][2])
# 使用for循环遍历结果将数据放到对象中
users = []
for idd, name, age in result:
    print(idd, name, age)
    users.append(User(idd, name, age))

print(users)
# 查看对象内存地址
print(hex(id(users[0])))

26、方法种类

class Demo:
    clazz = 88

    def __init__(self, name):
        self.name = name

    # 实例方法 - 通过实例对象调用
    def f(self):
        print(self.name)

    # 静态方法 - 可以用实例进行调用，也可以直接使用类名进行调用(推荐)
    @staticmethod
    def m():
        print('好好学习，天天向上')

    # 类方法 - 可以用实例进行调用，也可以直接使用类名进行调用(推荐)
    @classmethod
    def n(cls):  # cls代表当前类对象
        print(cls.clazz)

d = Demo('tom')
d.f()
d.m()
Demo('mike').m() # 当通过对象调用对象的方法时，因为对象有实例方法，需要传参
Demo.m()
Demo.n()
d.n()