[Python知识库]day 57 Python

一、Python

1、数据容器

类似于 java 中的集合，Python 包含四大数据容器

元组tuple、列表list、集合set、字典dict

1、元祖 tuple

特点：
1、元素类型可以不唯一
2、元素允许重复
3、初始化后，其中元素不可修改
4、输入输出有序

定义：

tuple1 = (1,1,1,2,2,3,4,5,'a',True)

获取：

tuple1[0]

关于元祖推导式

a = (i for i in range(1, 101))
print(a)

不同于其他推导式，元祖推导式返回的是一个生成器
直接打印会输出该生成器的地址
生成器是迭代器的一种，因此可以使用 next() 来遍历
但

2、列表 list

特点：
1、元素类型可以不唯一
2、元素允许重复
3、初始化后，其中元素可以修改
4、输入输出有序

定义：

list1 = [1, 1, 1, 2, 3, 'a', 1.1, True]

切片：

左闭右开，因此右侧需要多取一位，允许自右向左，最右为-1
最后的参数为步长，会从左边的起始位开始移动，默认为1

list1[6:10]

# 倒序输出
list1[::-1]

修改：

list1[1] = 'A'

增加：

# 末尾增加
list1.append('last')

#指定位置增加
list1.insert(3, 1.1)

删除：

# 末尾删除
list1.pop()

# 根据指定值自右向左删除一个
list1.remove(1)

# 指点位置删除元素
del list1[0]

排序：

list2 = [1, 5, 4, 2, 10, 3, 7, 6, 9, 8]

# 正序输出
list2.sort()

# 倒序输出
list2.sort(reverse=True)

查找（返回索引）：

list2.index(7)

合并：

# + 不会改变原有的list
print(list1 + list2) 
 
# 会对list2造成修改
list1.extend(list2)  

反转：

list2.reverse()

统计元素出现次数：

list2.count(1)

清空列表：

list2.clear()

3、集合 set

特点：
1、元素类型可以不唯一
2、元素不允许重复，初始化时会自动去重
3、初始化后，其中元素可以修改
4、输入输出无序

定义：

set1 = {1,1,2,2,3,'a'，True}

添加：

set1.add(5)

集合的运算：

set2 = {1, 2, 3, 4, 5, 6}
set3 = {4, 5, 6, 7, 8, 9}

# 并集
print(set2 & set3)

# 交集
print(set2 | set3)

# 差集
print(set2 - set3)

4、字典 dict

特点：
1、每一个元素都是 key ：value 格式（类似 java 中的 map）
2、key 不允许重复，且必须不可变（四个基本数据类型，和 tuple），value 随意
3、初始化后，其中元素可以修改
4、没有索引，通过 key 来获取数据
5、key 中，True 和 1 会相互覆盖，False 和 0 会相互覆盖
6、查询速度不会随着元素增多而变慢（key）

定义：

dict1 = {
    -1:-1,
    2:2,
    1:1,
    0:0,
    True:2,
    False:2,
    1:3,
    0:3
}

获取：

dict1[-1]

# 推荐使用 get，当数据不存在不会报错卡掉运行
dict1.get(-1,'如果key不存在就输出这一句')

# 获取的 key
dict1.keys()

# 获取所有的 values
dict1.values()

# 将每个 kv 对封装成 tuple ,所有对封装成一个 list
dict1.items()

2、选择结构

if
elif
else

# Python中以冒号（:）空格（缩进）区分代码块
if 表达式1:
    代码1(前面四个空格)    
    代码2(前面四个空格)    
elif 表达式2:
    代码3(前面四个空格)
...
else 表达式3:
    代码4(前面四个空格)    

3、循环结构

while 循环（python 中没有 do while）

while 表达式:
    循环体代码1
    循环体代码2

 while i <= 100:
    sum += i
    i += 1  # 没有 ++ -- 类似的操作
print(sum)   

for 循环（注意左闭右开）

for i in range(1,3):
    print('*',end='')

关于一行代码九九乘法表

print('\n'.join('\t'.join('{} * {} = {}'.format(i,j,i*j) for j in range(1,i+1)) for i in range(1,10)))

本质是两个列表推导式的缩写（此处用小括号，所以这里是元祖推导式）
和其他推导式不同的是，元祖推导式返回的是一个生成器，使用方法和迭代器类似

4、文件 IO

读和写都归到 open 函数中

1、读文件

# 读文件
# 注意路径中不能使用\
# mode r=read w=overwrite a=append
f1 = open("C:/Users/fgh/PycharmProjects/fghPython/day58/source/students.txt", mode='r', encoding='utf8')
# read(n) 表示读n个字符
# readline 从当前指针读到下一个换行符\n
# readlines 读所有的行 并构成list返回

print(f1.read(10))
print(f1.readline())
print(f1.readline())
# 此处两个line各有一个换行符
print(f1.readlines())

# 关闭文件
f1.close()

2、写文件

f2 = open("C:/Users/fgh/PycharmProjects/fghPython/day58/source/stu.txt", mode='w', encoding='utf8')

# 换行需要手动加上 \n
f2.write("必须传入字符串1\n")
f2.writelines(['一行数据\n', '一行数据\n'])

# 关闭文件
f2.close()

3、with open（能够嵌套使用，并且会自动关闭通道）

# with open 不需要手动的关闭文件
# 读取 student.txt的数据并写入stu.txt

with open("C:/Users/fgh/PycharmProjects/fghPython/day58/source/students.txt", mode="r", encoding='utf8') as f3:
    with open("C:/Users/fgh/PycharmProjects/fghPython/day58/source/stu.txt", mode='a', encoding='utf8') as f4:
        f4.writelines(f3.readlines())

5、连接 MySQL

# 操作MySQL
# pip install pymysql
import pymysql

# 创建连接
conn = pymysql.connect(user='root', passwd='123456', host='master', port=3306, database='student')

# 创建游标 类似statement
cursor = conn.cursor()
# 返回最后查询出来的条数
t = cursor.execute("select name,age from student where clazz like %s and gender= %s and age > %s", ('理科%', '男','25'))
print("总计记录数：", t)

# print(cursor.fetchone())  # 返回一条记录
# print(cursor.fetchmany(3))  # 返回n条记录
# print(cursor.fetchall())  # 返回所有记录 注意使用
for i in range(t):
    print(cursor.fetchone())

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

同样可以使用 with

with pymysql.connect(user='root', passwd='123456', host='master', port=3306, database='student') as conn:
    with conn.cursor() as cursor:
        nums = cursor.execute("select name,age from student where clazz like %s and gender= %s and age > %s",('理科%','男','25'))
        for i in range(nums):
            print(cursor.fetchone())
        # conn.rollback() # 发生错误进行回滚
        # conn.commit() # 没有异常直接提交

6、日期转换

# 格式化日期字符串
from datetime import datetime

# 字符串转datetime,parse,注意大小写
dt = datetime.strptime("2021-12-13 16:41:38", "%Y-%m-%d %H:%M:%S")
print(dt, type(dt))

print(dt.year)
print(dt.month)
print(dt.day)
# 显示当日周几，周一是0
print(dt.weekday())

# datetime转字符串,format
# 2021/12/07 16:41:38
date_str = datetime.strftime(dt, "%Y/%m/%d %H:%M:%S")
print(date_str, type(date_str))

7、函数

'''
  不需要访问权限修饰符
  也不需要返回值类型
def 函数名(参数1,参数2......):
    代码块
    代码块
    代码块
    代码块
    # 如果需要返回值
    return 返回值
'''
# 计算1~n的和
def sum1toN(n1):
    sum = 0
    i = 1
    while i <= n1:
        sum += i
        i += 1
    return sum
res = sum1toN(100)
print(res)


# 计算N的阶乘
# 5!=5*4*3*2*1
# 两种方式：
# 1、循环
def jieCheng(n):
    res = 1
    while n >= 1:
        res *= n
        n -= 1
    return res
print(jieCheng(5))

递归函数

'''
  尽量避免使用递归函数 能用循环就用循环
  递归函数需要满足两个条件：
  自我调用
  递归出口
'''
# 5! = 5 * 4!
# 4! = 4 * 3!
# n! = n * (n-1)!
def jieCheng2(n):
    if n == 1:
        return 1
    return n * jieCheng2(n - 1)
print(jieCheng2(5))

匿名函数

'''
# lambda 表达式
# lambda 参数1,参数2......:返回值
# 计算x的y次方
'''
def ciFang(x, y):
    return x ** y
print(ciFang(2, 3))

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

8、函数参数的类型

1 位置参数（必选参数）
及平常使用的参数

2 默认参数（可以不传，有默认值）

'''
# 默认参数 y,可以不传
# 计算x的y次方 如果不传入y则默认计算x的2次方
'''
def cifang2(x, y=2):
    return x ** y

print(cifang2(2))
print(cifang2(2, 3))

3 可变参数（可以传入仍以数量，转化为 tuple）

'''
# 传入n1,n2 就 返回n1+n2
# 传入n1,n2,n3 就 返回n1+n2+n3
'''
def sumN(*args):
    # args是参数名
    # 要操作传入的参数 可以对args（相当于有参数构成的tuple）进行遍历
    print(args, type(args))
    sum = 0
    for i in args:
        sum += i
    print(sum)

sumN(1, 2)
sumN(1, 2, 3)

4 关键字参数（可以不传，底层是 dict）

'''
# 关键字参数,按需要传入
# 传入时一定要写明种类(key)
# 实际会存储为 dict
# 注册函数：
# name、age、addr(可选)、phone(可选)
'''
def register(name, age, **kw):
    print(kw, type(kw))

register("张三", '20', addr="大别野", phone="18888888888")

5 命名关键字参数（必须得传，传入时必须要带上对应的key）

'''
# 必须要传入
# 传入时必须要带上对应的key
# 前一个参数有 * ，下一个就是命名关键字参数
'''
def register2(name,age,*,gender):
    print(name,age,gender)

register2('fgh','21',gender='男')

print('#' * 100)


# 需要注意不同参数之间的顺序，如可变参数不能在位置参数之前
def register3(name, age='18', *args, gender, **kw):
    print(name, age, args, gender, kw)

register3("小红", '18', gender='女')
register3("小红", '18', 1, 2, 3, 4, 5, 6, 7, gender='女')

二、面向对象

1、类

# 定义类
# 封装方法和变量（属性）
# object是所有类的基类 相当于Java中的Object
class Person(object):
    # 构造函数
    # 类中所有的方法的第一个参数都是self：代表对象本身 相当于Java中的this
    def __init__(self, id, name, gender):
        # 定义了类的属性并进行赋值
        self.id = id
        self.name = name
        self.gender = gender
        # 如果定义的属性不想被直接获取 可以在命名的时候以两个下划线开头
        self.__secret = '这是一个秘密'

    def info(self):
        print("Person", self.id, self.name, self.gender)

    def run(self):
        print("我会跑")

    # 相当于Java中的toString方法 在使用print函数打印该类的对象时会自动调用
    # 重写object中的方法
    def __str__(self):
        return "Person类的对象 %s" % self.name


# 创建对象
zs = Person('001', '张三', '男')
print(zs)
print(zs.id)
print(zs.name)
print(zs.gender)
# print(zs.__secret) # 不能直接获取 相当于进行了 "封装"
# Python中没有严格意义上的封装 更多地是靠编程者良好的编程习惯去约束
# 还是可以通过 _类名+属性名 去将隐藏的属性取出来
print(zs._Person__secret)

zs.info()


class Teacher(Person):
    def __init__(self, id, name, gender):
        # 调用父类的构造方法
        super(Teacher, self).__init__(id, name, gender)
        self.professional = 'compute'

    def info(self):
        print("Teacher", self.id, self.name, self.gender, self.professional)


t1 = Teacher("张老师", "24", "男")
print(t1.id)
print(t1.name)
print(t1.professional)
t1.info()
t1.run()


class Student(Person):
    def __init__(self, id, name, gender):
        # 调用父类的构造方法
        super(Student, self).__init__(id, name, gender)
        self.skill = 'play game'

    def info(self):
        print("Student", self.id, self.name, self.gender, self.skill)

    def run(self):
        print("我跑的很快")


stu1 = Student("李四", "20", "男")


# 定义一个方法接收Person类型的参数 然后对run方法调用两次
# 多态：父类引用指向子类对象
# 但是实际上python是不检测实参类型的，所以多态也不是那么准确
def runTwice(person: Person):
    person.run()
    person.run()

runTwice(zs)
runTwice(t1)
runTwice(stu1)

# 鸭子类型：只要长得像鸭子那么就是鸭子
# 更多的是关注变量有没有方法 并不会对变量做类型的检查
class Duck():
    def run(self):
        print("鸭子也会跑")

dk = Duck()
runTwice(dk)


class Dog():
    pass

dog = Dog()

def run():
    print("狗也会跑")

# 猴子补丁
# 对成员的方法进行临时赋值，也可以被python识别
dog.run = run

runTwice(dog)

三、异常处理

a = 1
print(a)
# str1 = 'abc # 语法错误

# 六大常见的异常
# ZeroDivisionError 除零异常
# print(10/0)

# NameError 名称异常
# 变量、函数未定义就使用
# print(i)

# TypeError 类型异常
# print(10+"分") # 在python中int不能跟字符串直接相加

# ValueError 值异常
print(int("123"))
# print(int("abc"))

# IndexError 索引异常
list1 = [1, 2, 3]
print(list1[0])
print(list1[1])
print(list1[2])
# print(list1[3])

# AttributeError 属性异常
str1 = 'abcdef'
# str1.xxxx


# 异常处理
'''
try:
    可能会发生异常的代码
    可能会发生异常的代码
    可能会发生异常的代码
except 异常1:
    异常1发生了该怎么办
except 异常2:
    异常2发生了该怎么办
......
else:
    没有发生异常就会执行
finally:
    不管有没有发生异常都会执行   
'''

try:
    print("start")
    print(10 / 0)
    print("end")
# except Exception as e:
#     print(e)
except ZeroDivisionError as e:
    print(e)
    print("请检查除数")
except ValueError as e:
    print(e)
    print("如果发生了值异常该怎么处理")
else:
    print("没有发生异常就会执行")
finally:
    print("不管有没有发生异常都会执行")


# 自定义异常
class AlienError(Exception):
    pass


age = int(input("请输入一个年龄："))
# 判断是否成年
# 如果年龄不在0~200范围内直接抛出外星人异常
try:
    if age < 0 or age > 200:
        # print("年龄不符合规范")
        raise AlienError("发生了外星人异常")
    elif age >= 18:
        print("成年")
    elif age < 18:
        print("未成年")
except AlienError as e:
    print("捕获到了AlienError异常")
    print(e)