Python基础:选择语句、循环结构、数据库操作、文件IO流、函数、面向对象、编译异常

一、选择语句（if）

1、格式

if 表达式1:
    代码块1(缩进)
elif 表达式2:  # elif相当于else if 
    代码块2(缩进)
else:
    代码块3(缩进)

二、循环结构

1、for循环：

Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。

格式： for i in 列表或者字符串等等

                    代码块（缩进）

2、while循环

格式：
    while(表达1):
        代码块(需要缩进)
        代码块(需要缩进)
        代码块(需要缩进) 

#求5的阶乘
r = 5
s = 1
while (r > 0):
    s *= r
    r -= 1
print(s)

三、数据库操作

1、下载数据库

（1）换源：更换网站
    将pip文件夹复制到 C:\用户\当前用户

（2）在pycharm终端中输入命令

install:安装包
    格式：pip install <package>       安装PyMysql: pip install pymysql

    注：如果需要指定版本安装则需要使用 pip install <package> == version
uninstall: 卸载已安装的包
    格式: pip uninstall <已存在的包名>
list: 查看pip已安装的模块
    格式 pip list
help: 查看pip中的所有命令
    pip --help

3、连接使用数据库

import pymysql  # 导包

# 数据库连接
conn = pymysql.connect(user='root', password='123456', host='192.168.160.110', database="shujia", port=3306)
cu = conn.cursor()
# 输入sql语句
res = cu.execute("select * from emp")

# print(cu.fetchone())  # 获取一条数据
# print(cu.fetchmany(4))  # 获取指定数量的数据
# print(cu.fetchall()) # 获取所有的数据

for i in range(res):
    print(cu.fetchone())

# 关闭连接
cu.close()
conn.close()

'''
    with as 用法： 为了防止开发者忘记关闭我们的连接
'''
print('>>>' * 50)
with pymysql.connect(user='root', password='123456', host='192.168.233.10', database='company', port=3306) as conn:
    with conn.cursor() as cursor:
        res = cursor.execute("select * from emp where ENAME like %s", ('M%'))
        for i in range(res):
            print(cursor.fetchone())

四、文件IO流

'''
    encoding错误：文件格式错误
        UnicodeDecodeError: 'gbk' codec can't decode byte 0x90 in position 19: illegal multibyte sequence
    解决：
        encoding='utf8'
'''

# mode='r' 表示只读模式，从文件中读取数据
f1 = open(file="./data/students.txt", mode='r', encoding='utf8')
print(f1.read(15))  # 获取15位数据
print(f1.readline())  # 获取当前下标下的整行数据
print(f1.readline())
print(f1.readlines())  # 获取当前下标后的所有数据
f1.close()

# mode='w' 表示写入模式，覆盖写入
f2 = open(file="./data/write.txt", mode='w', encoding='utf8')
f2.writelines("输入一行数据\n")
f2.writelines("输入一行数据\n")
f2.writelines("输入一行数据\n")
f2.write("输入数据")
f2.close()

# mode=a 表示追加数据
f2 = open(file="./data/write.txt", mode='a', encoding='utf8')
f2.writelines("输入一行数据\n")
f2.writelines("输入一行数据\n")
f2.writelines("输入一行数据\n")
f2.write("输入数据")
f2.close()

'''
    需求：需要从students.txt中读取数据并写入 students_new.txt
'''
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())

五、函数

1、格式:

    def 函数名(参数1,参数2,参数3):
        代码块(需要缩进)
        代码块(需要缩进)
        代码块(需要缩进)
        # 需要返回值
            return 数据

'''
 1 -> n的和
'''

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

sumN(100)  #1到100的和

2、递归函数

'''
    递归函数：
        1.需要调用自己
        2.需要有一个停止标记
'''
# 阶乘
# 5! = 5 * 4 * 3 * 2 * 1

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

print(jiecheng(5))

3、参数

参数类型：位置参数、默认参数、可变参数、关键字参数

# 位置参数
'''
    特点：
        1. 位置参数可包含多个
        2. 函数调用时位置参数不能为空
'''
def chengfa1(a, b):
    print(a * b)

# 默认参数
'''
    特点：
        1.定义函数的时候，需要去指定参数的默认值
        2.使用时，可通过再次传入参数值进行覆盖默认值
'''


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

chengfa2(2)  #b为默认的0
chengfa2(2, b=3) #b为3

# 可变参数
'''
    特点：
        1.可变参数的写法需要在参数名之前加一个*如: *args
        2.可变参数实际是一个tuple
'''
def chengfa3(*args):
    print(args, type(args))
chengfa3(2, 3, 4, 5)
结果(2, 3, 4, 5) <class 'tuple'>

def chengfa4(*args):
    sum = 1
    for i in args:
        sum *= i
    print(sum)
chengfa4(4, 5, 6, 7)
结果840

# 关键字参数
'''
    特点：
        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="打游戏")
结果
zhangsan 23 {'gender': '男'} <class 'dict'>
zhangsan 23 {'gender': '男', 'skill': '打游戏'} <class 'dict'>

4、应用

# 判断传入参数有没有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)

5、匿名函数

# 获取x的y次方
lambda_function = lambda x, y: x ** y
print(lambda_function(2, 3))
结果8

六、 面向对象

1、类

特点：
    1.构造方法：需要重写 __init__方法
    2.对象属性：需要在 __init__ 方法中通过 self.属性名称 去定义
    3.获取对象的字符串信息： 需要重写 __str__ 方法
    4.定义对象的方法时：可以通过self.属性名去获取对应的属性名

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 相当于Java中的toString方法
    def __str__(self):
        return '\t'.join(["Person", self.name, str(self.age)]) #这里age做了个强制转换

    def skill(self):
        print(self.name + "能够直立行走...")

person1 = Person("张三", 24)
print(person1, type(person1))  #Person	张三	24 <class '__main__.Person'>
print(person1.age)             #24
print(person1.name)            #张三
person1.skill()                #张三能够直立行走...

2、封装

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.__secret = "这是一个秘密" #封装变量需要在名字前面加双_

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

    def skill(self):
        print(self.name + "能够直立行走...")

    def get(self):
        print(self.__secret)

person2 = Person("李四", 48)
person2.get()
# print(person2.__secret)  # 内部属性不能被外部对象访问
print(person2._Person__secret)  # 内部属性可以通过 _+类名+内部属性名进行访问，所以python没有严格的封装概念

3、继承

特点：
    1.如果一个新的类继承了已有的一个类，那么被继承的类叫 父类，新的类叫做子类
    2.范围大的一般被用来做父类，具体的一般用来做子类
    3.子类可以调用父类中的方法及属性
    4.如果子类中的函数与父类重名,则调用子类方法

#父类是上面的person
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("杨老师", 30)
print(t.name)
t.skill()
t.get()

1.可以通过对象的引用调用其方法
2.父类应用指向子类对象
3.Python中并不注重是否继承及检查类型，只注重有没有方法及属性

def run(person):
    person.skill()

person3 = Person("王", 40)
run(person3)

class Duck:
    def skill(self):
        print("鸭子可以游泳...")


duck1 = Duck()
run(duck1) #Python中并不注重是否继承及检查类型，只注重有没有方法及属性

4、补丁

如果创建了类，想要增加一个方法，可以使用补丁方法

class Dog:
    pass


# 创建一个函数
skill_functioni = lambda: print("是人是狗都在秀...")  #匿名方法

dog1 = Dog()

# 将函数赋值给dog作为dog新增的补丁方法
dog1.skill = skill_functioni
dog1.skill()

 七、编译异常

1、常见异常

'''
    六大常见异常：
        除零错误 ZeroDivisionError ：除数为0
        关键词错误 NameError ：没有定义直接使用
        值错误 ValueError ：某些函数或者方法只适用于特定的数据类型，如果 对数据类型的操作不当，就会产生类型错误 
        索引错误 IndexError: 超出索引取值范围
        属性错误 AttributeError : 调用不合适的方法或属性
        缩进错误 IndentationError: 没有按规定进行缩进(高版本有优化)

'''

# 属性错误
# AttributeError
# tuple = (1, 2, 3)
# tuple.append(1)

# 索引错误
# IndexError
# list = [1, 2, 4]
# print(list[4])

# 值错误
# ValueError
'''
a = "123"
print(int(a))
b = "abc"
print(int(b))
'''

# 除零错误
# ZeroDivisionError
# print(10 / 0)

# 语法错误
# SyntaxError
# print(")

# 缩进错误
# IndentationError
'''
for i in range(1,4):
   print(i)
    print(i)
'''

# 关键词错误
# NameError
# prin("hello")

2、捕获异常（try...catch）

'''
    格式：
        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")