如何安装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、运算符

算术运算符
image-20220331134932169比较运算符

image-20220331135102315

赋值运算符 =
a = 10
c = a + 1
print(c)
逻辑运算符

image-20220331135431970

9、列表与元组与字典

列表 [ ]:list

python最常用的数据类型,list

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

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

正索引:从0开始

img

values: 代表元素

indexs: 索引也称为下标

负索引/反向索引:下标从尾部开始,从-1开始

img

列表操作符:

image-20220401134221199

常用函数方法:

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

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

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

函数扩展:

image-20220401134644500

追加元素到列表末尾和:

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 下标越界错误
元组()

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

img

# 元组中只有一个元素时,必须补一个逗号
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使用。

image-20220402123409839

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 返回值
  • 函数的定义
    • 函数必须先定义后调用
    • 函数在定义阶段只检测语法不执行语法,简单讲就是自检,不执行输出
    • 函数只有在调用阶段才会执行函数体代码
  • 函数调用
    • 函数名加括号
    • 定义时有参数,需要传参
图了解函数

image

image

函数的分类:

内置函数

  • 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、装饰器

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

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

image

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

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()
版权声明:本文为枯树老鸭原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://www.cnblogs.com/kushulaoya/p/16196250.html