Day46 python中的选择循环结构、pip的安装与使用、面向对象、类与模块

Tian-Ys

已于 2022-03-28 21:26:09 修改

阅读量2.2k

点赞数 1

分类专栏：笔记文章标签： python

于 2022-03-25 22:36:15 首次发布

本文链接：https://blog.csdn.net/m0_64350718/article/details/123743810

版权

笔记专栏收录该内容

51 篇文章 2 订阅

订阅专栏

选择结构

python中的选择结构同Java有所不同

格式：

if 表达式1：

代码块1

elif 表达式2：

代码块2

else：

代码块3

举例：从键盘输入年龄，判断是否成年

引入： python中从键盘录入为input，默认为str类型，想要输入int类型需要加入类型转换

age = int(input("请输入年龄："))
if age <= 0 | age >= 180:
    print("数据错误")
elif age < 18:
    print("未成年")
else:
    print("已成年")

循环结构

python中为了简洁，没有Java中的do while循环

循环格式：for循环和while循环

for循环格式：

for 变量 in 表达式或者集合等

while循环格式：

while(表达式1)：

代码块

简单举例：计算5的阶乘

res = 1
n = 5
while (n >= 1):
    res *= n
    n -= 1
print(res)

结果：120

python连接mysql

使用pip下载mysql依赖

python中的pip类似于Java中的maven，都是用于存放下载依赖

在安装依赖前，由于pip默认连接的是外网，所以需要将pip文件移动到电脑中的C盘目录下的用户目录下的当前用户目录下，这样在连接时连接的就是国内网。

在Terminal控制台中输入命令pip install pymysql下载mysql依赖

出现successful就说明pymysql依赖安装成功，此时会提示需要更新pip，输入命令：

python -m pip install --upgrade pip进行pip版本的更新

若是时间过长超时，不知道是否更新成功，可以输入pip list查看当前已经安装的所有模块，检查pip的版本是否为22.0.4，若不是，则再次输入上述命令进行更新，时间过长原因可能是上面的pip文件位置出现错误，导致没有连接到国内网。

出现上述字样就是更新成功

注意：如果需要指定版本安装需要使用：pip install <package> == version

uninstall：卸载已安装的包：pip uninstall <已经存在的包>

mysql的连接与操作：

使用python连接mysql

先使用pymysql.connect去连接到所要操作的数据库，之后去获取游标

# 导包
import pymysql

# 创建连接
conn = pymysql.connect(user='root', password='123456', host='192.168.92.200', database='test', port=3306)
# 获取游标
cursor = conn.cursor()
# 获取结果集
res = cursor.execute("select * from emp where ENAME like %s",('M%'))
# 获取名称首字母是M开头的员工的所有信息
# 获取一条数据
# print(cursor.fetchone())
# 获取四条数据
# print(cursor.fetchmany(4))
# 获取全部数据
# cursor.fetchall()
for i in range(res):
    print(cursor.fetchone())
# 关闭游标和连接
cursor.close()
conn.close()

为了防止开发者忘记关闭连接，可以使用with。。。as来连接数据库，其余操作相同

with pymysql.connect(user='root', password='123456', host='192.168.92.200', database='test', port=3306) as conn:
    # 获取游标
    cursor = conn.cursor()
    # 获取结果集
    res = cursor.execute("select * from emp where ENAME like %s", ('M%'))
    for i in range(res):
        print(cursor.fetchone())

结果同上

文件IO

在python中使用文件IO，对文件进行操作使用open关键字，从源码中看出，open关键字中需要设置所要操作的文件路径和读写mode

mode='r'表示只读模式；mode='w'表示写入模式

读操作：

r= open(file="D:/PyCharmProjects/day46/data/students.txt", mode='r')
print(r.read(3))# 读取3行数据

这里在读取的时候会报错：

UnicodeDecodeError: 'gbk' codec can't decode byte 0x90 in position 19: illegal multibyte sequence

解决办法:在使用open时，需要在最后指定一个编码集utf8

正确写法：

r= open(file="D:/PyCharmProjects/day46/data/students.txt", mode='r', encoding='utf8')
print(r.read(12))  # 读取12个数据
print(r.readline())  # 获取当前下标下的整行数据
print(r.readline())
r.readlines()  # 获取当前下标后的所有数据

结果：

出现该结果的原因是在第一条输出语句执行后，读取了13个数据，但是此时第一行数据不止13个，光标在读取数据后处于第13个数据的后面，此时在执行第二条语句输出一行数据就会把剩下的数据进行输出

写操作：

同样也是使用open关键字，不同的地方在于mode

w=open(file="./write.txt",mode='w',encoding='utf8')
w.writelines("写入一行数据\n")
w.writelines("写入一行数据\n")
w.writelines("写入一行数据\n")
w.write("写入数据\n")

此时该文件下没有write.txt文件，该操作会自动创建一个write.txt文件，然后进行一个写操作

执行完后，进入write.txt中查看内容

追加操作：

向该文件中追加写入，使用mode='a'

a=open(file="./write.txt",mode='a',encoding='utf8')
a.writelines("追加一行数据\n")
a.writelines("追加一行数据\n")
a.write("追加数据\n")

结果：

需求：将write.txt中的内容读取并写入write_new.txt中

使用with as解决

with open(file="./data/students.txt", mode='r', encoding='utf8') as f3:
    with open(file='./data/students_new.txt',mode='a',encoding='utf8') as f4:
        f4.writelines(f3.readlines())

结果：

函数

函数的定义

定义格式：

def 函数名(参数1，参数2...):

代码块

# 需要返回值，不需要时不用写

return 数据

简单举例：计算1到100的和

def sumN(n):
    sum = 0
    for i in range(n):
        sum += i
    print(sum)

sumN(101)

结果：因为range是左闭右开区间，所以要写101

递归函数：计算5的阶乘

def jiecheng(n):
    if n == 1:
        return 1
    else:
        return n * jiecheng(n - 1)

print(jiecheng(5))

结果：

函数的参数

根据类型分为四类：位置参数，默认参数，可变参数，关键字参数

位置参数：

特点：

1、位置参数可以设置多个；2、函数调用时位置参数不能为空

位置参数就是上述案例中所见到的方法中的参数

默认参数：

特点：

1.定义函数的时候，需要去指定参数的默认值；

2.使用时，可通过再次传入参数值进行覆盖默认值

举例：

def chengfa2(a, b=0):
    print(a * b)

chengfa2(2)
chengfa2(2, b=3)

结果：

可变参数：

特点：

1.可变参数的写法需要在参数名之前加一个*如: *args

2.可变参数实际是一个tuple

举例：

def chengfa4(*args):
    sum = 1
    for i in args:
        sum *= i
    print(sum)

chengfa4(1,2,3,4)

结果：

关键字参数：

特点：

1.定义参数时需要用**参数名表示关键字参数如：**kwargs

2.类型是一个字典类型

3.传入时需要按照k=v形式进行传入

4.可以接收多个kv参数

举例：

def info(name, age, **kwargs):
    print(name, age, kwargs, type(kwargs))

info("zhangsan", 23, gender="男")
info("zhangsan", 23, gender="男", skill="打游戏")

结果：

需求：判断传入的参数有没有age，有则输出age，没有则提示请输入age

def info2(name, **kwargs):
    if ('age' in kwargs.keys()):
        print("age:", kwargs["age"])
    else:
        print('请输入age')

info2(name="lisi")
info2(name="wangwu", age=3)

结果：

匿名函数

获取x的n次方：**表示次方

lambda_function = lambda x, y: x ** y
print(lambda_function(2, 3))

结果：

面向对象

封装

封装的特点：

1.构造方法：需要重写 __init__方法

2.对象属性：需要在 __init__ 方法中通过 self.属性名称去定义

3.获取对象的字符串信息：需要重写 __str__ 方法

4.定义对象的方法时：可以通过self.属性名去获取对应的属性名

创建一个类Person：

# 这是一个类Person
class Person:
    # 定义构造方法
    def __init__(self, name, age):
        self.name = name
        self.age = age
        # 定义私有变量，在变量前加上__
        self.__secret = "this is a secret"

    # 相当于Java中的toString方法
    def __str__(self):
        return "\t".join(["Person", self.name, str(self.age)])

    # 成员方法
    def skill(self):
        print(self.name + "可以走路")
    # Get方法
    def get(self):
        print(self.__secret)

# 创建对象使用该类中的方法
person1 = Person("张三", 24)
# 输出person1
print(person1)
# 无法直接获取其中的__secret
# print(person1.__secret)
# 需要调用get方法来获取私有变量
person1.get()
# 调用成员方法
person1.skill()
# 可以使用另一种格式访问
print(person1._Person__secret)

同Java一样，不可以直接通过对象直接访问私有变量，会报错：

AttributeError: 'Person' object has no attribute '__secret'

但是可以使用另一种格式访问私有变量：_+类名+内部属性名

这里self表示自身的对象，与Java中的this类似

结果：

继承

定义一个老师类继承Person类，python中想要实现继承关系需要在创建子类时在子类后加上父类的名称

继承关系的特点：

1.如果一个新的类继承了已有的一个类，那么被继承的类叫父类，新的类叫做子类

2.范围大的一般被用来做父类，具体的一般用来做子类

3.子类可以调用父类中的方法及属性

4.如果子类中的函数与父类重名,则调用子类方法

class Teacher(Person):
    # 构造方法
    def __init__(self, t_name, t_age):
        # 如果需要构建父类对象，需要传入父类中所需的参数，并且super中需要传入子类名称及其self
        super(Teacher, self).__init__(name=t_name, age=t_age)
        self.teach = "computer"

    def skill(self):
        print("努力做好大数据")


# 创建对象
t = Teacher("李四", 26)
print(t)
t.skill()
t.get()

结果：

多态

多态关系的特点：

1.可以通过对象的引用调用其方法

2.父类应用指向子类对象

3.Python中并不注重是否继承及检查类型，只注重有没有方法及属性

举例：

def run(person: Person):
    person.skill()

person2=Person("赵",20)
run(person2)

t2=Teacher("孙",30)
run(t2)
#创建一个普通类，与Person没有继承关系
class Duck:
    def skill(self):
        print("鸭子可以游泳")

duck=Duck()
run(duck)

结果：

结果发现：虽然定义了一个参数为Person类型的run方法，但是一个普通的Duck类也可以使用run方法进行调用，这也就是多态的第三个特点

猴子补丁

在python中，当创建完一个类后，突然在某一时刻想要给这个类中添加一个方法的时候，可以使用猴子补丁将方法添加到该类中

举例：

#创建一个类，类中什么都没有，使用pass表示
class Animal:
    pass

# 创建一个匿名函数
function1=lambda:print("你好世界")
#创建对象
animal=Animal()
#将函数赋值给animal对象作为animal新增的补丁方法
animal.skill=function1
#调用
animal.skill()

结果：

类与模块

模块是Python中的最高级别组织单元，它将程序代码和数据封装起来以便重用

模块的三个角色:

1. 代码重用

2. 系统命名空间的划分(模块可理解为变量名的封装，即模块就是命名空间)

3. 实现共享服务和数据

当文件中含有__init__.py时，该文件就成为了一个包

模块就存储在该包下

模块的特点：

1.导入模块时，会去执行模块中的代码块

2.模块的两种导入方法 import ... from 包 import

3.方法和模块导入方式一致

举例：模块A

# 模块A
hello = "A"
print(hello)

def print_hello():
    print("this is ModelA..")

模块B

# 模块B
hello1 = "B"
print(hello1)

def print_hello():
    print("this is ModelB..")

在一个普通的py文件中导入两种模块

from package1 import ModelA
from package1 import ModelB

该文件中没有任何内容，只是导入了模块A和模块B，运行结果：

若是不想运行模块A中的方法，但是又需要调用模块A时，可以在模块A中加入一个main

这样在导入模块后不会去自动加载模块中的内容，而是只加载main中的内容

调用模块中的方法也是一样的

from package1.ModelA import print_hello

print_hello()

结果：

同时可以给模块起别称来调用，调用时只需要使用别称.方法名即可

使用sys可以查看当前包的文件路径

import sys
print(sys.path)

异常及异常处理捕获

python中有六大常见异常：

除零错误 ZeroDivisionError ：除数为0

关键词错误 NameError ：没有定义直接使用

值错误 ValueError ：某些函数或者方法只适用于特定的数据类型，如果对数据类型的操作不当，就会产生类型错误

索引错误 IndexError: 超出索引取值范围

属性错误 AttributeError : 调用不合适的方法或属性

缩进错误 IndentationError: 没有按规定进行缩进(高版本有优化)

关于异常的捕获

捕获格式：

try:

         可能出现问题的代码块

         可能出现问题的代码块

         可能出现问题的代码块

except 捕获异常种类1 as 异常种类别名:

         出现异常种类1，执行...

except 捕获异常种类2 as 异常种类别名:

         出现异常种类2，执行...

else:

         没有发生异常可以执行...

finally:

         不管有没有错误都执行...

捕获异常的特点：

1.当出现多个错误时，以程序运行顺序捕获错误为主

2.当捕获异常时，如果出现较大范围的异常类型时，以较大范围的异常为主（注：异常存在继承关系）

# 捕获单一错误
try:
    print("start")
    tuple = (1, 2, 3)
    tuple.append(1)
    print("end")
except AttributeError as attribute:
    print(attribute)
    print("已经捕获到异常:AttributeError")
finally:
    print("不管有没有错误都执行...")

# 捕获多种类型错误，以程序运行顺序捕获异常错误
try:
    print("start")
    print(10/0)
    tuple = (1, 2, 3)
    tuple.append(1)
    print("end")
except ZeroDivisionError as zero:
    print(zero)
    print("捕获到除零错误...")
except AttributeError as attribute:
    print(attribute)
    print("已经捕获到异常:AttributeError")

print('>>>'*20)
# 以较大异常为主
try:
    print("start")
    print(10/0)
    tuple = (1, 2, 3)
    tuple.append(1)
    print("end")
except Exception as e:
    print(e)
    print("捕获到异常...")
except ZeroDivisionError as zero:
    print(zero)
    print("捕获到除零错误...")

结果：

Numpy的安装

Numpy 是一个专门用于矩阵化运算、科学计算的开源Python

在控制台中输入pip Install numpy，按下回车，开始安装

安装成功为上述图例

import numpy as np

data = [
    [1, 2, 3],
    [4, 5, 6]
]
np_arr = np.array(data)
print(np_arr, type(np_arr))

# jupyter notebook
# 安装：pip install jupyter notebook
# 使用：jupyter notebook

# np_arr.astype()

print(np_arr[:,1])
print(np.split(np_arr,2))

print(np_arr.reshape(3,2))

print(np_arr+np_arr)
print(np_arr-np_arr)
print(np_arr*np_arr)
print(np_arr/np_arr)

结果：

jupyter notebook

jupyter notebook是专门用于演示一些比较简单或者需要可视化的数据的工具

为了更好的使用numpy，这里引入一个新的第三方工具jupyter notebook

下载jupyter notebook

在控制台输入命令：pip install jupyter notebook进行下载安装

由于该工具包比较大，对网络要求较高，所以当下载失败时，可能时网络问题，重新下载即可

jupyter notebook的使用：

输入命令：jupyter notebook，按下回车，一般情况下会自动跳转到一个网页，若没有跳转，则手动点击运行结果中的网址即可

点击该网址即可成功跳转到网页

这就可以在网页中进行书写代码及运行代码

代码运行命令：

ctrl+Enter：运行该行代码

alt+Enter：运行该行代码并开启下一行

关闭jupyter notebook：按下ctrl+C或者Ctrl+D退出jupyter notebook，没有反应可以尝试多次。

Tian-Ys

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Day46 python中的选择循环结构、pip的安装与使用、面向对象、类与模块

选择结构python中的选择结构同Java有所不同格式：if 表达式1：代码块1elif 表达式2：代码块2else：代码块3举例：从键盘输入年龄，判断是否成年引入： python中从键盘录入为input，默认为str类型，想要输入int类型需要加入类型转换age = int(input("请输入年龄："))if age <= 0 | age >= 180: print("数据错误")e...
复制链接

扫一扫