Python（自学笔记）

Python视频课程
开发环境：pycharm(community)

第一章：出使Python国

1.输出函数print()函数

"""
print()函数
时间：2023/7/15 14:42
"""
#可以输出数字
print(520)
print(12.5)

#可以输出字符串
print('hello world!')
print('hello world!')

#含有运算符的表达式
print(2+1)

#将数据输出文件中
fp = open('E:/test.txt', 'a+')
#print("hello world!", fp)      无法把内容写入文件中，要使用file=对象
print("hello world!", file=fp)
fp.close()

#不进行换行输出（print()默认输出后换行）
print('hello', end = '\t')
print('world')
print("hello", 'world', 'Python')               #变量之间默认添加空格来分隔
print("hello", 'world', 'Python', sep = '-')    #使用sep = ''方法改变分隔符

#格式化输出
name='zs'
age='20'
print("我的名字是{0}，今年{1}岁。".format(name, age))

2.转义字符

"""
转义字符
时间：2023/7/15 15:17
"""
# \+转义字母
print("helloworld")
print("hello\nworld")       #\n 换行符
print("hello\rworld")       #\r 回车
print("hello\tworld")       #\t 制表位
print("hello\bworld")       #\b 退格

print('http:\\\\baidu.com') #打印一个转义字符： \ + 转义字符
print("老师说：\'大家好\'")

# 原字符输出，不希望转义字符起作用就在输出前加r或R
print(r'hello\nworld')
# print(r'hello\nworld\')      #最后一个字符不能是’\‘
print(r'hello\nworld\\')      #最后一个字符可以是’\\‘

3.二进制字符编码

"""
二进制编码
时间：2023/7/15 15:43
"""
# 二进制编码，使用UTF-8编码标准每个编码使用两个字节
print(chr(0b100111001011000))   #编码表示
print(ord('乘'))                 # 十进制表示

4.标识符，保留字，关键字

"""
关键字，保留字,标识符
时间：2023/7/15 15:49
"""
# 变量，函数，类，模块，和其它对象的起的名字叫标识符
# 标识符，命名规则：
# 字母， 数字， 下划线
# 不能以数字开头
# 不能是保留字
# 严格区分大小写
import keyword
print(keyword.kwlist)               # 打印关键字

5.变量的定义和使用

"""
变量的定义和使用
时间：2023/7/15 15:53
"""
name = '玛丽亚'
print(name)
print('ID::', id(name))
print('类型:', type(name))
print('值:', name)

name = '谷景涵'
print('ID::', id(name))
print('类型:', type(name))
print('值:', name)

name2 = '谷景涵'
print('ID::', id(name2))
print('类型:', type(name2))
print('值:', name2)
"""
玛丽亚
ID:: 2446861415888
类型: <class 'str'>
值: 玛丽亚
ID: 2446861595728
类型: <class 'str'>
值: 谷景涵
ID:: 2446861595728          #“编辑器“中和把赋值语句放在”同一行的cmd环境“中，相同值的不同变量会指向同一个地址
类型: <class 'str'>
值: 谷景涵
"""

6.数据类型

6.1 整型

"""
整型数据类型
时间：2023/7/16 8:42
"""
# 整形数据范围
n1 = 100
n2 = -10
n3 = 0
print(n1, type(n1))
print(n2, type(n2))
print(n3, type(n3))

# 整数可以表示为二进制，十进制，八进制，十六进制
print('十进制', 16)
print('二进制', 0b10000)
print('十六进制', 0x10)
print('八进制', 0o20)

6.2 浮点型

"""
浮点型数据类型
时间：2023/7/16 8:52
"""
a = 3.14159
print(a, type(a))
n1 = 1.1
n2 = 2.2
n3 = 2.1
print(n1 + n2)                  # 3.3000000000000003----由于浮点数也是由二进制数表示，所以会存在不精确的情况
print(n1 + n3)                  # 3.2
# 使用下面代码正确计算浮点数
from decimal import Decimal
print(Decimal(n1) + Decimal(n2))            #3.300000000000000266453525910
print(Decimal('1.1') + Decimal('2.2'))      #3.3

6.3布尔型

"""
bool型数据类型
时间：2023/7/16 9:01
"""
f1 = True
f2 = False
print(f1, type(f1))
print(f2, type(f2))

# bool值可以当作整形数值计算
print(f1 + 1)           # 2

6.4字符串

"""
字符串
时间：2023/7/16 9:05
"""
str1 = '加油，奥里给！'
str2 = "加油，奥里给！"
str3 = '''加油，
        奥里给！'''
print(str1)
print(str2)
print(str3)

7.数据类型转换

"""
数据类型转换
时间：2023/7/16 9:09
"""
name = '张三'
age = 20
print(type(name), type(age))                    # 说明name与age的数据类型不相同
# print('我叫'+name+'今年'+age+'岁')           # 将str类型数据与int型数据连接时报错，需要使用强制数据类型转换
print('我叫'+name+'今年'+str(age)+'岁')

# str数据类型转换
a = 10
b = 1.1
c = False
d = a+b+c
print(a+b+c)
print(type(d))
print(type(a), type(b), type(c))
print(str(a)+str(b)+str(c))

# int数据类型转换
a1 = 1.1
b1 = '1.1'
c1 = '1'
print(int(a1))                      # 1
# print(int(b1))                    # error str型数据必须位整数串
print(int(c1))                      # 1

# float数据类型转换
a2 = 1
b2 = '1.1'
c2 = '1'
print(float(True))                  # 1.0
print(float(a2))                    # 1.0
print(float(b2))                    # 1.1
print(float(c2))                    # 1.0

8.编码注释

"""
编码注释
时间：2023/7/16 9:47
"""
# coding:utf-8
# 中文编码格式

第二章 算你赢

1.输入函数input()

"""
input()函数
时间：2023/7/16 9:53
"""
c = input("请输入一个礼物：")
print(c, type(c))

a = input('请输入一个加数')
b = input('请输入另一个加数')
print(type(a), type(b))
print(int(a)+int(b))

2.运算符

"""
运算符
1.算术运算符
2.赋值运算符
3.比较运算符
4.布尔运算符
5.位运算
时间：2023/9/13 17:09
"""
# 1.算术运算符
"""
print(1+1)
print(1-2)
print(2*4)
print(1/2)
print(11//2)
print(11%2)
print(2**2)

# 整除的问题
print(9//4)
print(-9//-4)
print(9//-4)        #-3
print(-9//4)        #-3     错误原因，向下取整

# 取余的问题
print(9%-4)         # -3 公式 余数 = 被除数 - 除数乘以商   -3 = 9 -（-4）* （-3）
print(-9%4)         # 3
"""

# 2.赋值运算符
"""
# 赋值运算符，运算顺序从右到左
i = 3+4
print(i, id(i))

#支持链式赋值
a = b = c = 20
print(a, id(a))
print(b, id(b))
print(c, id(c))         # a,b,c三个引用分别存储id对象值，他们都指向一个存储为整型的存储空间

#支持参数赋值
a += 10
a -= 10
a *= 10
a /= 10
a //= 10
a %= 10

#系列解包赋值
a, b, c = 10, 20, 30
print(a, b, c)

#交换两个变量的值
a, b = 10, 20
a, b = b, a
print(a, b)
"""

# 3.比较运算符
"""
# 比较运算符的结果为bool类型
a, b = 10, 20
print(a > b)
print(a == b)
print(a < b)
print(a >= b)
print(a <= b)
print(a != b)

# 变量由 标识（id），类型，值组成 

a = 10
b = 10
print(a == b)                   # true '=='比较对象为变量的值
print(a is b)                   # true ‘is’比较对象的标识
print(a is not b)               # true

lst1 = [11, 22, 33, 44]
lst2 = [11, 22, 33, 44]
print(lst1 == lst2)
print(lst1 is lst2)
print(id(lst1))
print(id(lst2))
"""

# 4.布尔运算符
"""
a, b = 1, 2

# and运算符，and-都为真才为真
print(a == 1 and b == 2)        #true

# or运算符，有一个真即为真
print(a == 1 or b != 2)         #true

# not运算符， 取反
print(not False)                #true

# in 与 not in
s = 'hello world!'
print('o' in s)                 #true
print('s' not in s)             #true
"""

# 5.位运算
"""
# 二进制按位运算
print(4 & 8)                # &同为1才为1
print(4 | 8)                # |有1则为1

# 移位,左移n位相当于乘以2^n，右移n位相当于除以2^n
print(4 << 1)
print(4 << 2)
print(4 >> 1)
print(4 >> 2)

# 算术运算， 位运算， 比较运算， bool运算，赋值运算
"""

第三章 往哪走

1.对象的布尔值

Python一切皆对象

"""
对象的bool值
时间：2023/7/16 14:26
"""
# 对象的bool值位False
print(bool(False))
print(bool(0))
print(bool(0.0))
print(bool(None))
print(bool(''))
print(bool(""))
print(bool([]))             #空列表
print(bool(list()))         #空列表
print(bool(()))             #空元组
print(bool(tuple()))        #空元组
print(bool(dict()))         #空字典
print(bool(set()))          #空集合

2.选择结构

"""
选择结构
时间：2023/7/16 14:24
"""
# 选择结构
## 取款程序
m = 1000            # 金额为1000
if m >= 0:
    print(f'您的余额为：', m)
else:
    print('您的余额不足！')
s = input("请输入取款金额：")
m = m - int(s)
if m >= 0:
    print('取款成功，您的余额为：', m)
else:
    m = 1000
    print('余额不足取款失败!')

## 输入一个数，判断为奇数还是偶数
n = int(input("请输入一个整数："))
if n % 2 == 0:
    print("这个数为偶数！")
else:
    print('这个数为奇数！')

## 成绩等级判定
score = int(input("请输入一个分数："))
if score < 0 or score >100:
    print('成绩输入错误！')
elif 90 <= score <= 100:
    print('A')
elif 80 <= score <=90:
    print('B')
elif 60 <= score <=80:
    print('C')
else:
    print('D')

## 会员折扣
mon = int(input('请输入金额：'))
cus = input('您是会员吗？是的话输入y,不是输入n')
if(cus == 'y'):
    if mon >= 200:
        mon = mon * 0.8
    elif mon >=100:
        mon = mon * 0.9
    else:
        print('不打折')
else:
    if mon >=200:
        mon = mon * 0.95
    else:
        print('不打折！')
print("最终价格是：", mon)

## 使用条件表达式判断
a = input()
b = input()
print(a + '大于等于' + b if a > b else a + '小于' + b)        #if后判断为真执行前边的语句，为假执行后边的语句

3.pass语句

#pass语句什么都不做，只是一个占位符，
cus = input()
if(cus == 'y'):
    pass
else:
    pass

第四章 转圈圈

1.range()函数的使用

"""
range()的三种创建方式
时间：2023/7/16 15:34
"""
# 第一种，只有一个参数
r = range(10)               #默认从0开始，步长为1的整数
print(r)
print(list(r))

# 第二种，含有两个参数
r = range(1, 10)            #从第一个数开始，结束不包括第二个数
print(list(r))

#第三种，含有三个参数
r = range(1, 10, 2)         #从1开始到9，步长为2
print(list(r))

#判断指定整数在序列中是否存在
print(9 in r)

2.循环结构

"""
循环结构
时间：2023/7/16 15:46
"""
# for循环         for 自定义变量 in 可迭代对象
for item in 'Python':
    print(item)

# 求1-100偶数和(while循环)
sum = 0
a = 1
## while循环
while a <= 100:
    if a % 2 == 0:
        sum = sum + a
    a += 1
print(sum)

## 求1-100偶数和(for循环)
sum = 0
r = range(1, 101, 1)
for i in r:
    if i % 2 == 0:
        sum = sum + i
print(sum)

3.流程控制语句

"""
break用法
时间：2023/7/16 16:05
"""
for i in range(3):
    pwd = input("请输入密码：")
    if pwd == '88888888':
        print('密码正确！')
        break
    else:
        print('密码错误！')
 
"""
continue的用法
时间：2023/7/17 13:42
"""
# 要求输出1到50之间所有5的倍数

## 用法一
print('不使用continue。')
for item in range(1, 51):
    if item%5 == 0:
        print(item)

## 方法二
print('使用contine。')
for item in range(1, 51):
    if item%5 != 0:
        continue
    print(item)

第五章 一字排开

1.列表

"""
列表
时间：2023/7/17 14:59
"""
# 1.简单的列表
lst = ['hello', 'world', 98]
print(id(lst))
print(type(lst))
print(lst)

# 2.创建列表对象

##第一种方式
lst = ['hello', 'world', 98]                    #lst 为一个列表对象其值为存储'hello', 'world', 98的三个id值，每个值指向存储元素的id值

##第二种方式
lst2 = list(['hello', 'world', 98, 'hello'])    #列表元素可以重复

print(lst[0], lst[-3])
print(lst2.index('hello'))                      #有多个相同元素，只返回第一个元素的标签

# 3.切片操作        start=1, stop=6, step=1
lst3 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
lst4 = lst3[1:6:1]
print(id(lst3), id(lst4))                       #切片是新创建的一个列表，并把切片内容放入切片中
print(lst3)
print(lst4)

# 4.列表元素的判断及遍历
print(10 in lst3)
for i in lst3:
    print(i)

# 5.列表元素添加操作
lst3 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
lst4 = [110, 120]

## append -- 像列表末尾添加
print('添加元素之前：', id(lst3))
lst3.append(110)
print('添加元素之后：', id(lst3))
lst3.append(lst4)                                   #把lst4列表当作一个元素添加到lst3列表末尾
print(lst3)
lst3.extend(lst4)
print(lst3)                                         #把lst4列表的元素依次添加到lst3列表末尾

## insert -- 在任意位置添加
lst3.insert(1, 0)
print(lst3)

lst3[1:] = lst4
print(lst3)

# 6.列表元素的删除

## remove -- 移除指定元素
lst = [10, 20, 30, 40, 50, 30]
lst.remove(30)                      #重复元素只移除第一个
#lst.remove(60)                     error
print(lst)

## pop -- 删除索引元素
lst.pop(1)                          #删除索引元素
print(lst)                          #默认删除最后一个元素

## 切片 -- 产生一个新的列表对象
new_lst = lst[1:3]
print(lst)
print(new_lst)

lst[1:3] = []
print(lst)

## clear -- 清除列表的所有元素
lst.clear()
print(lst)

## del -- 删除列表对象
del lst
# print(lst)                列表不存在

# 7.修改列表元素
lst = [10, 20, 30, 40, 50]

## 一次只修改一个值
lst[2] = 0                  #修改的并不是原来索引为2的值，而是重新创建一个值为0的对象，并指向新对象
print(lst)

## 使用切片修改列表中的多个值
print(id(lst))
lst[1:3] = [200, 300, 400, 5000]
print(lst)
print(id(lst))
# 8.列表元素排序
lst = [10 ,30, 20, 50, 40]
print('排序前的列表：', lst)

# 使用sort()方法排序
lst.sort()
print('默认升序排序后的列表：', lst)
lst.sort(reverse=True)
print('通过修改reverse参数降序排序的列表：', lst)
# 使用内置函数sorted()对列表进行排序，产生一个新列表
new_uplst = sorted(lst)
new_downlst = sorted(lst, reverse=True)
print(lst)
print(new_uplst)
print(new_downlst)

# 9.列表生成式
lst = [i for i in range(1, 10)]
print(lst)

2.字典

"""
字典
时间：2023/7/18 14:15
"""
# 1.字典的原理：
## 字典和列表一样都是可变序列,字典的键是不可变序列,键值对

# 2.字典的创建
## 第一种创建方式
scores = {'张三':60, '李四': 50, '王五':80}
print(scores)
print(type(scores))

## 第二种创建方式
studnt = dict(name = 'jack', age = 20)
print(studnt)

## 创建空字典
d = {}
print(d)

# 3.获取字典中的元素
scores = {'张三':60, '李四': 50, '王五':80}
## 使用'[]'
print(scores['张三'])
## 使用’get()方法
print(scores.get('王五'))

# 4.键的判断
scores = {'张三':60, '李四': 50, '王五':80}
print('张三' in scores)

del scores['张三']            # 删除指定键值对
#scores.clear()               # 清空字典元素
print(scores)

# 5.新增元素
scores['陈六'] = 98           #新增元素

# 6.修改元素
scores['陈六'] = 100          #修改元素

# 7.视图操作
scores = {'张三':60, '李四': 50, '王五':80}
## 获取所有key
keys = scores.keys()
print(keys)
print(type(keys))
print(list(keys))
##获取所有value
Values = scores.values()
print(Values)
print(type(Values))
print(list(Values))
##获取所有kay-value
items = scores.items()
print(items)
print(type(items))
print(list(items))

# 8.字典元素的遍历
for i in scores:                            # 键不允许重复不可以改变，因此列表不能作为字典的键，值可以重复
    print(i, scores[i], scores.get(i))
d = {'name':'张三', 'nickname':'张三'}
print(d)

# 9.字典生成式
## 内置函数zip()                以短序列为准
name = ['张三', '李四', '王五']
score = [60, 50, 80, 100, 100, 100]
d = {name:score for name, score in zip(name, score)}
print(d)
name = ['张三', '李四', '王五']
score = [60, 50]
d = {name:score for name, score in zip(name, score)}
print(d)

3.元组

'''
元组
时间：2023/7/19 8:54
'''
# 1.元组
## 元组是不可变序列，不能对序列进行增删改操作

# 2.元组的创建方式
## 第一种，直接创建
t = ('python', 'hello', 90)
t2 = 'python', 'hello', 90

## 第二种，使用内置函数tuple
p = tuple(('python', 'hello', 90))

## 只包含一个元素用逗号隔开,不用逗号为str类型
o = ('python', )
o2 = ('python')
print(type(o), type(o2))
print(t,t2, p, o)

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

# 3.为什么要将元组设计成不可变序列
## 在多任务环境下，同时操作对象不需要加锁。--只读
## 如果元组的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变。
t = (10, [20, 30], 9)
print(t)
print(type(t))
print(t[0], t[1], t[2])
print(type(t[0]), type(t[1]), type(t[2]))

t[1].append(100)
print(t)

# 4.元组的遍历
t = (10, [20, 30], 9)
## 第一种，使用索引
print(t[0])

## 第二种，使用for循环
for ti in t:
    print(ti)

4.集合

"""
集合
时间：2023/7/19 9:21
"""
# 1.集合
## 集合是没有value的字典

# 2.集合的创建
## 第一种，使用{}
s = {1, 2, 3, 4, 5, 5, 7, 7, 64}        #集合的元素不允许重复
print(s)

## 第二种，使用set()
s1 = set(range(6))
print(type(s1))
print(s1)

s2 = set([1, 2, 3, 4, 5, 5, 7, 64])
s3 = set((1, 2, 3, 4, 5, 5, 7, 7, 64))
s4 = set('python')
s5 = set({1, 2, 3, 4, 5, 5, 7, 7, 64})
s6 = set()
print(s2, s3, s4, s5, s6)

# 3.集合的判断操作
s = {10, 20, 30, 40}
print(10 in s)
print(50 in s)

# 4.集合元素的新增操作
s.add(80)
print(s)
s.update({200, 300, 400})
print(s)
s.update([201, 301, 401])
s.update((202, 302, 402))
print(s)

# 5.集合元素的删除操作
## remove()
s.remove(200)
print(s)
#s.remove(100)   `       #不存在报异常

## discard()
s.discard(100)           #不存在不报异常
print(s)

## pop()
s.pop()                 #pop()不能指定参数，删除随机一个值
print(s)

## clear()
s.clear()               #清空集合元素
print(s)

# 6.集合之间的关系
## 两个集合是否相等
s = {10, 20, 30}
s2 = {30, 10, 20}
print(s == s2)              # True

## 一个集合是否是另一个集合的子集,超集，交集
s1 = {10, 20, 30}
s2 = {10, 20}
s3 = {40, 10}
print(s2.issubset(s1))      #子集
print(s1.issuperset(s2))    #超集
print(s1.isdisjoint(s3))    #交集，有交集为False

## 集合的数学操作
s1 = {10, 20, 30}
s2 = {10, 20, 40}
s3 = {40, 10}

print(s1.intersection(s2))
print(s1 & s2)              #交集操作,intersection与 &等价

print(s1.union(s2))
print(s1 | s2)              #并集，两种方式等价

print(s1.difference(s2))
print(s1 - s)               #差集，二者等价

print(s1.symmetric_difference(s2))
print(s1 ^ s2)              #对称差集,等价

# 7.集合生成式
s = {i for i in range(10)}
print(s)

第六章 一串连一串

1.字符串

"""
字符串
时间：2023/7/20 13:45
"""
# 字符串是基本数据类型，是一个不可变的字符序列
# 1.字符串的驻留机制，进保存一份相同且不可变的字符串的方法，不同的值被存放在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量
a = 'python'
b = "python"
print(id(a))
print(id(b))            #id相同
## 驻留机制的几种情况（交互模式下及cmd）
##(1)字符串的长度为0或1
##(2)符合标识符的字符串
##(3)字符串只在编译时进行驻留，而非运行时
##(4)[-5,256]之间整数
## sys的intern方法强制2个字符串指向一个对象，pycharm对字符串进行了优化处理

# 2.字符串的常用操作
s = 'hello,hello'

## (1)查找操作
## index        查找字符串第一次出现的位置
print(s.index('lo'))
## find         查找字符串第一次出现的位置
print(s.find('lo'))
## rindex       查找字符串最后一次出现的位置
print(s.rindex('lo'))
## rfind        查找字符串最后一次出现的位置
print(s.rfind('lo'))

## (2)大小写转换,upper(), lower(), swapcase(), capitalize(), title()
s = 'hello, python'
a = s.upper()
print(a, id(a))
print(s, id(s))
print(s.lower(), id(s.lower()))
b = s.lower()
print(b, id(b))
print(s.swapcase())
print(s.capitalize())
print(s.title())

## (3)字符串内容对齐操作, center(), ljuast, rjust, zfill
s = 'hello, Python'

'''居中'''
print(s.center(20, '*'))

'''左对齐'''
print(s.ljust(20, '*'))
print(s.ljust(10))
print(s.ljust(20))

'''右对齐'''
print(s.rjust(20, '*'))
print(s.rjust(20))
print(s.rjust(10))

'''右对齐，使用0进行填充'''
print(s.zfill(20))
print(s.zfill(10))
print('-1000'.zfill(8))

## (4)字符串的劈分
s = 'hello world Python'
lst = s.split()
print(lst)

s1='hello|world|Python'
lst1 = s1.split(sep='|')                #设置分隔符
print(lst1)
lst2 = s1.split(sep='|', maxsplit=1)    #设置最大划分数
print(lst2)

s = 'hello world Python'
lst3 = s.rsplit()
print(lst3)
print(id(lst))
print(id(lst3))

## (5)字符串判断， isidentifier(), isspace(), isalpha(), isdecimal(), isnumeric(), isalnum()
s = 'hello world Python'
print('1.', s.isidentifier())       #判断是否为合法标识符

print('2.', 't'.isspace())          #判断是否为空格字符

print('3.', 'abc'.isalpha())        #判断字符串是否为字母

print('4.', '123'.isdecimal())      #判断字符串是否全由十进制数组成

print('5.', '123四'.isnumeric())     #判断字符串是否都由数字组成

print('6.', '1张三'.isalnum())       #判断是否由字母和数字组成

## (6)替换与合并，replace(), join()
## replace()第一个参数指定被替换的子串，第二个参数指定替换字串的字符串，该方法返回替换后得到的字符串，替换前的字符串不发生变化，第三个参数可以限制替换次数
s = 'hello, Python'
print(s.replace("Python", 'Java'))
print(s.replace("Python", 'Java', 2))
## join()将将列表或元组中的字符串合并成一个字符串
lst = ['hello', 'Java', 'Python']
print(''.join(lst))
print('*'.join('Python'))

## (7)字符串的比较操作
print('apple' > 'app')      #Ture
print('apple' > 'banana')   #False 相当于97>98 ->False

## (8)字符串的切片操作, 切片[start:end:step]不包含end
s = 'hello,Python'
print(s[:5])
print(s[6:])
print(s[:5] + ',' + s[6:])

print(s[1:5:1])

# 3.格式化字符串
print('%10d'% 99)               #10表示的是宽度
print('%.3f'% 3.1415926)        #.3f表示小数点后三位
print('{0:.3}'.format(3.1415926))   #.3表示一共三位数，.3f表示小数点后三位

# 4.字符串的编码转换
s = '天涯共此时'
## 编码
print(s.encode(encoding='GBK'))
print(s.encode(encoding='UTF-8'))
##解码
byte = s.encode(encoding='GBK')         # 编码
print(byte.decode(encoding='GBK'))      # 解码

第七章 水晶球不调不动

1.函数

"""
函数
时间：2023/7/21 13:31
"""
# 1.函数的定义
def calc(a, b):             # a, b为形参
    c = a+b
    return c
result = calc(1, 5)         # 1， 5为实参，根据位置传递参数
print(result)

def can(a, b):
    return a
result = can(b=10, a=5)     #关键字参数
print(result)

# 2.参数的传递
def fun(arg1, arg2):
    print('arg1=', arg1)
    print('arg2=', arg2)
    arg1 = 100
    arg2.append(10)
    print('arg1=', arg1)
    print('arg2=', arg2)

n1 = 11
n2 = [22, 33, 44]
print(n1)
print(n2)
fun(n1, n2)
print(n1)
print(n2)
'''
在函数调用过程中，
如果是不可变对象，则不会改变实参的值，arg1修改为100不改变n1的值
如果是可变对象，则会改变实参的值，arg2为可变对象，arg2 被改变n2的值也会被改变
'''

# 3.函数的返回值
def fun(num):
    odd=[]              # 存奇数
    even=[]             # 存偶数
    for i in num:
        if i%2 != 0:
            odd.append(i)
        else:
            even.append(i)
    return odd, even    # 返回值为元组
print(fun([10, 11, 12, 13, 14]))
'''
函数返回值为1个时返回原类型，当返回值为多个时返回值为元组类型
'''

# 4.函数的参数的定义
def fun1(a, b=10):      # b=10为默认值，类似于print()函数的end='\,'
    print(a, b)
fun1(100)

## 个数可变的位置参数
def fun2(*args):        # 不知道形参个数时使用*变量名，类型为元组
    print(args)
    print(args[0])
fun2(10)
fun2(10, 20)
## 个数可变的关键字形参

def fun2(**args):       # 类型为字典
    print(args)
fun2(a=10)
fun2(a=10, b=20)

def fun3(*args1, **args2):
    pass

# 5.函数的调用
def fun4(a, b, c):
    print(a, b, c)
lst = [10, 20, 30]
fun(*lst)               # 在列表前加*可以提取列表中的每个元素

def fun5(a, b=10, *c, **d):
    pass

2.递归函数

"""
递归函数
时间：2023/7/21 14:32
"""
# 递归函数求阶乘
def fac(n):
    if(n == 1):
        return 1
    sum = n * fac(n-1)
    return sum
print(fac(5))

# 递归求斐波那契数列
def fib(n):
    if n == 1:
        return 1
    elif n == 2:
        return 1
    else:
        return fib(n-1)+fib(n-2)
print(fib(6))

for i in range(1, 7):               #输出前六个数字
    print(fib(i))

第八章 异常处理机制

1.try…except…

"""
异常处理
时间：2023/7/21 14:58
"""
# try...except...结构
try:
    a = int(input())
    b = int(input())
    c = a/b
    print(c)
except ZeroDivisionError:       # 捕获0作为除数的错误
    print('除数不能为0')
except ValueError:
    print('请输入数字串！')
print('程序结束！')

# try...except...else...结构
try:
    a = int(input())
    b = int(input())
    c = a / b
except BaseException as e:      # 捕获所有可能出错的情况
    print('出错了', e)
else:                           # 没错就执行else
    print(c)
# try...except...else...finally...结构
try:
    a = int(input())
    b = int(input())
    c = a / b
except BaseException as e:
    print('出错了', e)
else:
    print(c)
finally:                        # 无论是否出错，都会执行
    print('不管是否出错，都继续执行')
# 手动掏出异常
score = int(input('请输入分数：'))
if 0<=score<=100:
    print('分数为：', score)
else:
    raise Exception('分数不正确!')

第九章 找对象不积极思想有问题

1.类与对象

"""
类和对象
时间：2023/7/22 15:45
"""
# 1.类的创建
class Student:                      #Student为类名，一般首字母大写，其余字母小写。
    def __init__(self, sno):
        self.sno = sno

    def study(self):
        print(f'{self.sno}学的是英语！')

stu = Student(1001)
stu.study()
print(id(Student))
print(type(Student))
print(Student)

class Student1:                      #Student为类名，一般首字母大写，其余字母小写。
    pass

print(id(Student1))
print(type(Student1))
print(Student1)

class Student:                      # 同名的类有不同的id值,并覆盖原有的类
    native_place = '吉林'            # 类属性
    # 实例方法，类内定义的成为方法，类外定义为函数

    def __init__(self, name, age):   # __init__ 初始化方法，name, age为实例属性
        self.name = name
        self.age = age

    def eat(self):
        print(self.name, '在吃饭')
    # 静态方法
    @staticmethod
    def method():                   #没有参数
        print('使用了staticmethod方法进行修饰，所以是静态方法')
    # 类方法
    @classmethod
    def cm(cls):                    #默认cls为参数
        print('使用classmethod方法进行修饰，所以是类方法')

def drink():                        #类外定义为函数
    print("喝水")

# 2.创建类的对象
stu1 = Student('张三', 20)            #Student为类对象，stu1为实例对象
print(id(stu1))
print(type(stu1))
print(stu1)
stu1.eat()                          # 对象名.方法名()
Student.eat(stu1)                   # 类名.方法名(类的对象)二者等价
print(stu1.name)
print(stu1.age)

# 3.动态绑定属性和方法
stu1 = Student('张三', 20)
stu2 = Student('李四', 30)            #一个Student类可以创建N多个Student类的实例对象，每个实例对象的属性值不同

## 为Stu2动态绑定性别属性                # 为Stu2动态绑定性别属性
stu2.gender = '女'
print(stu1.name, stu1.age)
print(stu2.name, stu2.age, stu2.gender)

stu1.eat()
stu2.eat()

## 绑定方法
def show():
    print('定义类之外为函数')
stu2.show = show                        #为stu2动态绑定方法

2.封装，继承，多态

"""
面向对象三大特征：封装，继承，多态
封装：提高程序的安全性
继承：调高代码的复用性
多态：提高程序的可扩展性和可维护性
时间：2023/7/23 9:12
"""
# 1.封装的实现
class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.__model = model                # model属性不希望在类定义之外使用，使用'__'
    def show(self):
        print(self.brand, self.__model)
    def start(self):
        print('汽车已启动')

car = Car('宝马x5', 2012)
car.start()
print(car.brand)
# print(car.__model)                        # __model不能在外部使用
car.show()
print(dir(car))                             # 出现_Car__model
#print(car._Car__model)                     # 能够强制获取属性

# 2.继承的实现
"""
如果一个类没有任何继承类，则默认继承object
Python支持多继承
定义子类时，必须在其构造函数中调用父类的构造函数
"""
class Person(object):                           # 父类
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def info(self):
        print(self.name, self.age)
class Stu(Person):                              #Person的子类
    def __init__(self, name, age, stu_no):
        super().__init__(name, age)             #继承父类方法
        self.stu_no = stu_no
    def info(self):                             #方法重写
        super().info()
        print(self.stu_no)
    def __str__(self):                          #方法重写
        return '重写了__str__()方法'
class Teacher(Person):                          #Person的子类
    def __init__(self, name, age, teach_of_year):
        super().__init__(name, age)
        self.teach_of_year = teach_of_year
    def info(self):                             #方法重写
        super().info()
        print(self.teach_of_year)
stu = Stu('zs', 20, '1001')
teacher = Teacher('ls', 34, 10)

stu.info()
print('-------------')
teacher.info()

# 3.object类
"""
object类时所有类的父类，因此所有类都有object类的属性和方法
内置函数dir()查看所有方法

"""
print(dir(object))
print(stu)                                          #默认调用object类的__str__()方法
print(type(stu))

# 4.多态

class Animal(object):
    def eat(self):
        print('动物会吃')
class Dog(Animal):
    def eat(self):
        print('狗会吃骨头')
class Cat(Animal):
    def eat(self):
        print('猫吃鱼')

class Person(object):
    def eat(self):
        print('人吃五谷杂粮')

## 定义一个函数
def fun(obj):
    obj.eat()

## 调用函数
fun(Cat())
fun(Dog())
print('----------')
fun(Person())
fun(Animal())

# 5.特殊的属性,__dict__,__bases__,
class A:
    pass
class B:
    pass
class C(A, B):                          # 继承了A和B
    def __init__(self, name):
        self.name = name

x = C('jack')

# __dict__
## 查看实例对象属性：值的字典 {'name': 'jack'}
print(x.__dict__)
## 查看类对象属性：方法的字典 {'__module__': '__main__', '__init__': <function C.__init__ at 0x0000019502DAD700>, '__doc__': None}
print(C.__dict__)

# __class__
print(x.__class__)                          #<class '__main__.C'>对象所属的类

# __base__
print(C.__bases__)                          #(<class '__main__.A'>, <class '__main__.B'>),父类的元组

# __mro__
print(C.__mro__)                            # 类的层次结构

# __subclasses__
print(A.__subclasses__())                   # 子类的列表

# 6.特殊方法
# __add__()
a=20
b=100
c=a+b                                      
d=a.__add__(b)                              # 两个整数类型对象的相加操作

print(c)
print(d)

class Student:
    def __init__(self, name):
        self.name = name
    def __add__(self, other):               #实现两个对象相加
        return self.name+other.name
    def __len__(self):
        return len(self.name)

stu1 = Student('张三')
stu2 = Student('李四')

s = stu1+stu2
print(s)

# __len__
print(len(stu1))

# __new__
class Person(object):

    def __new__(cls, *args, **kwargs):
        print('__new__被调用执行了，cls的id值为{0}'.format(id(cls)))
        obj=super().__new__(cls)
        print('创建的对象的id为：{0}'.format(id(obj)))
        return obj
    def __init__(self, name, age):
        print('__init__被调用了，self的id值为：{0}'.format(id(self)))
        self.name=name
        self.age=age
print('object这个类对象的id为：{0}'.format(id(object)))
print('Person这个类对象的id为：{0}'.format(id(Person)))

#创建Person类的实例对象
p1 = Person('张三', 20)
print('p1这和个Person类的实例对象的id:{0}'.format(id(p1)))

# 7.类的赋值
class CPU:
    pass
class Dick:
    pass
class Computer:
    def __init__(self, cpu, disk):
        self.cpu=cpu
        self.disk=disk
cpu1 = CPU()
cpu2 = cpu1
print(cpu1)
print(cpu2)

# 8.浅拷贝
disk = Dick()
computer = Computer(cpu1,disk)

import copy
computer2 = copy.copy(computer)
print(computer, computer.cpu, computer.disk)
print(computer2, computer2.cpu, computer2.disk)

# 9.深拷贝
computer3 = copy.deepcopy(computer)
print(computer, computer.cpu, computer.disk)
print(computer3, computer3.cpu, computer3.disk)

第十章 百宝箱

1.模块

"""
模块
自定义模块calc
时间：2023/7/24 9:39
"""
import time

# 1.模块的使用
"""print(pow(2, 3))
import math
print(id(math))
print(type(math))
print(math)
print(dir(math))

from math import pi
print(pi)
print(math.pow(2, 3))"""

# 2.导入自定义模块

"""import calc
print(calc.add(10, 20))"""

"""from calc import add            # 导入自定义模块中的方法
print(add(10, 20))"""

# 3.以主程序运行
"""import calc
print(calc.add(10, 20))             # 30    30       结果中包含calc模块的内容"""

# 4.包
"""
包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下
包含__init__.py文件的目录称为包
"""

# 5.常用内置模块
"""import sys
import time
import urllib.request

# getsizeof()获取所占字节数
print(sys.getsizeof(24))

#time()
print(time.time())
print(time.localtime(time.time()))

#request
print(urllib.request.urlopen('http://www.baidu.com').read())"""

# 6.安装模块
import schedule
import time

def job():
    print("haha---")
schedule.every(3).seconds.do(job)
while True:
    schedule.run_pending()
    time.sleep(1)

2.tracebck模块

"""
traceback模块
时间：2023/7/22 13:41
"""
import traceback
try:
    print('-----------')            #多次运行法相该行打印信息可能出现在前也可能出现在后，涉及到全栈开发的线程问题
    print(1/0)
except:
    traceback.print_exc()

第十一章 百宝箱

"""
文件读写
时间：2023/7/25 13:57
"""
#1. 读写文本文件
file = open('a.txt', 'r')
print(file.readlines())
file.close()

file1 = open('b.txt', 'w')
file1.write('Python')
file1.close()

file1 = open('b.txt', 'a')
file1.write('Python')
file1.close()

#2. 读写二进制文件
"""src_file = open('2.png', 'rb')
target_file = open('copy2.png', 'wb')
target_file.write(src_file.read())
target_file.close()
src_file.close()"""


# 3.文件对象常用方法
## read()
## readline()
## readlines()
## writelines()
"""file2 = open('c.txt', 'a')
ls = ['10', '20', '30']
file2.writelines(ls)"""

## seek()
## tell()
"""file2 = open('c.txt', 'r')"""
#file2.seek(2)           # 0表示从开头位置开始计算，1表示从当前位置开始计算，2表示从文件尾开始计算
"""print(file2.read())
print(file2.tell())
file2.close()"""

## flush()
"""file3 = open('d.txt', 'a')
file3.write('hello')
file3.flush()
file3.write('world')
file3.close()"""
# 4.上下文管理
"""
MycontentMgr实现了特殊方法__enter__(), __exit__()称为该对象遵守了上下文管理器协议
该类对象的实例对象，称为上下文管理器
"""
"""class MycontentMgr(object):
    def __enter__(self):
        print('enter方法被调用执行了')
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit方法被调用执行了')

    def show(self):
        print('show方法被调用执行了')

with MycontentMgr() as  file:       #相当于file=MyContentMgr()
    file.show()   """

"""with open('2.png', 'rb') as src_file:    # 不需要手动关闭文件，上下文管理器包含了关闭文件方法
    with open('copy1.png','wb') as target_file:
        target_file.write(src_file.read())"""

import os
import os.path
#直接打开系统的可执行文件
"""os.system('notepad.exe')
os.system('calc.exe')"""

#直接调用可执行文件
"""os.startfile('D:\Genshin Impact\launcher.exe')"""

"""print(os.getcwd())              #返回当前工作位置

#os.makedirs('A/B/C')            #创建多级目录

os.rmdir('A/B/C')"""

"""
# 返回绝对路径
print(os.path.abspath('hello.py'))
# 判断文件是否存在
print(os.path.exists('hello.py'), os.path.exists('calc.py'))
# 将目录与文件名拼接
print(os.path.join('D:\data_set','hello.py'))
# 分离文件名和扩展名
# 从一个目录中提取文件名
# 从一个路径中提取文件路径，不包括文件名
# 判断是否为路径"""

"""
# 获取指定目录的所有.py文件
path = os.getcwd()
lst = os.listdir(path)
for filename in lst:
    if filename.endswith('.py'):
        print(filename)"""

学生管理系统

"""
学生管理系统
时间：2023/7/27 13:45
"""
import os

filename = 'studentdata.txt'

def menu():
    print('=========================学生管理系统=========================')
    print('--------------------------功能菜单---------------------------')
    print('\t\t\t\t\t\t1.录入学生信息')
    print('\t\t\t\t\t\t2.查找学生信息')
    print('\t\t\t\t\t\t3.删除学生信息')
    print('\t\t\t\t\t\t4.修改学生信息')
    print('\t\t\t\t\t\t5.排序')
    print('\t\t\t\t\t\t6.统计学生总人数')
    print('\t\t\t\t\t\t7.显示所有学生信息')
    print('\t\t\t\t\t\t0.退出')
    print('-------------------------------------------------------------')
def main():
    while True:
        menu()
        choice = int(input('请选择：'))
        if choice in [0, 1 ,2, 3, 4, 5, 6, 7]:
            if choice == 0:
                answer = input('您确定要退出系统吗？Y/N')
                if answer == 'y' or answer == 'Y':
                    print('感谢您的使用!')
                    break
                else:
                    continue
            elif choice == 1:
                insert()                #录入学生信息
            elif choice == 2:
                search()                #查找学生信息
            elif choice == 3:
                delete()                #删除学生信息
            elif choice == 4:
                modify()                #修改学生信息
            elif choice == 5:
                sort()                  #对学生信息排序
            elif choice == 6:
                total()                 #统计学生总人数
            elif choice == 7:
                show()                  #显示所有学生信息
        else:
            print('输入错误，请重新输入!')
"""
insert()方法存在bug:
1.存在学号重复问题
2.手动删除文本内容会空首行
"""
def insert():                           #录入学生信息
    student_list = []
    while True:
        id = input('请输入ID(如1001)：')
        if not id:                      #id是否为空
            break
        name = input('请输入姓名：')
        if not name:
            break

        try:
            chinese = int(input('请输入语文成绩：'))
            math = int(input('请输入数学成绩：'))
            english = int(input('请输入英语成绩：'))
        except:
            print('输入无效，不是整数！')
            continue
        # 将录入信息改成字典
        student = {'id':id, 'name':name, 'chinese':chinese, 'math':math, 'english':english}
        student_list.append(student)
        answer = input('是否继续添加？Y/N')
        if answer == 'y' or answer == 'Y':
            continue
        else:
            break
    save(student_list)
    print('学生信息录入完毕！')
def search():                           #查找学生信息
    student_qurry = []
    while True:
        id = ''
        name = ''
        if os.path.exists(filename):
            s_mode = input('按id查找请输入1，按姓名查找请输入2')
            if s_mode == '1':
                id = input('请输入学生id：')
            elif s_mode == '2':
                name = input('请输入学生姓名：')
            else:
                print('输入错误，请重新输入')
                search()
            with open(filename, 'r', encoding='utf-8') as rfile:
                student = rfile.readlines()
                for item in student:
                    d = dict(eval(item))
                    if id != '':
                        if d['id'] == id:
                            student_qurry.append(d)
                    elif name != '':
                        if d['name'] == name:
                            student_qurry.append(d)
            # 显示查询结果
            show_student(student_qurry)
            # 清空列表
            student_qurry.clear()
            answer = input('是否要继续查询？Y/N')
            if answer == 'y' or answer == 'Y':
                continue
            else:
                break
        else:
            print('暂未保存学生信息')
            return
"""
delete()存在bug
功能完善：
增加删除确认功能
"""
def delete():                           #删除学生信息
    while True:
        student_id = input("请输入要删除学生的id:")
        # 判断输入内容是否为空
        if student_id != '':
            # 判断文件内容是否为空，把文件内容读入列表student_old
            if os.path.exists(filename):
                with open(filename, 'r', encoding='utf-8') as rfile:
                    student_old = rfile.readlines()
            else:
                student_old = []
            flag = False                #是否修改的标记
            if student_old:
                with open(filename, 'w', encoding='utf-8') as wfile:
                    d = {}
                    for item in student_old:
                        d = dict(eval(item))        #eval()为还原输入格式
                        if d['id'] != student_id:
                            wfile.write(str(d)+'\n')
                        else:
                            flag = True
                    if flag:
                        print(f"id为{student_id}的学生信息已被删除！")
                    else:
                        print(f'没有找到id为{student_id}的学生信息')
            else:
                print('文件无学生信息！')
                break
            # 删除后打印现在文件的学生信息
            show()
            answer = input('是否继续删除学生信息：Y/N')
            if answer == 'y' or answer == 'Y':
                continue
            else:
                break
def modify():                           #修改学生信息
    show()
    if os.path.exists(filename):
        with open(filename, 'r', encoding='utf-8') as rfile:
            student_old = rfile.readlines()
    else:
        return
    student_id = input('请输入要修改的学员的id：')
    with open(filename, 'w', encoding='utf-8') as wfile:
        for item in student_old:
            d = dict(eval(item))
            if d['id'] == student_id:
                print('找到学生信息！开始修改学生信息')
                while True:
                    try:
                        d['name'] = input('请输入姓名：')
                        d['chinese'] = input('请输入语文成绩')
                        d['math'] = input('请输入数学成绩')
                        d['english'] = input('请输入英语成绩')
                    except:
                        print('您的输入有误，请重新输入！')
                    else:
                        break
                wfile.write(str(d)+'\n')
                print('修改成功')
            else:
                wfile.write(str(d)+'\n')
    answer = input('是否继续删除学生信息？Y/N')
    if answer == 'y' or answer == 'Y':
        modify()
    else:
        return
def sort():                             #对学生信息排序
    show()
    if os.path.exists(filename):
        with open(filename, 'r', encoding='utf-8') as rfile:
            studemt_list = rfile.readlines()
        student_new = []
        for item in studemt_list:
            d = dict(eval(item))
            student_new.append(d)
    else:
        return
    asc_or_desc = input('请选择0.升序，1.降序：')
    if asc_or_desc == '0':
        asc_or_desc_bool = False
    elif asc_or_desc == '1':
        asc_or_desc_bool = True
    else:
        print('您的输入有误，请重新输入！')
        sort()
    s_mode = input('请输入排序方式0.按总成绩排序，1.按语文成绩排序，2.按数学成绩排序，3.按英语成绩排序，4.按照学号排序')
    if s_mode == '0':
        student_new.sort(key=lambda x :int(x['chinese'])+int(x['math'])+int(x['english']), reverse=asc_or_desc_bool)
    if s_mode == '1':
        student_new.sort(key=lambda x :int(x['chinese']), reverse=asc_or_desc_bool)
    if s_mode == '2':
        student_new.sort(key=lambda x :int(x['math']), reverse=asc_or_desc_bool)
    if s_mode == '3':
        student_new.sort(key=lambda x :int(x['english']), reverse=asc_or_desc_bool)
    if s_mode == '4':
        student_new.sort(key=lambda x :int(x['id']), reverse=asc_or_desc_bool)
    show_student(student_new)
def total():                            #统计学生总人数
    if os.path.exists(filename):
        with open(filename, 'r', encoding='utf-8') as rfile:
            students = rfile.readlines()
            if students:
                print(f'一共有{len(students)}名学生的信息')
            else:
                print('还没有录入学生信息！')
    else:
        print('暂未保存数据信息！')
def show():                             #显示所有学生信息
    student_lst = []
    if os.path.exists(filename):
        with open(filename, 'r', encoding='utf-8') as rfile:
            students =rfile.readlines()
            for item in students:
                student_lst.append(eval(item))
            if student_lst:
                show_student(student_lst)
    else:
        print('暂未保存数据信息')
def save(lst):                          #在insert()中调用，保存输入的学生信息，以列表保存在studentdata.txt文件中，列表的每个元素为学生信息的字典
    try:
        stu_txt = open(filename, 'a', encoding='UTF-8')
    except:
        stu_txt = open(filename, 'w', encoding='UTF-8')
    for item in lst:
        stu_txt.write(str(item)+'\n')
    stu_txt.close()
def show_student(lst):                  #在search()中调用，格式化展示查询到的学生信息
    if len(lst) == 0:
        print('，没有查询到学生信息，无数据显示！')
        return
    # 定义标题显示格式
    format_title = '{:^6}\t{:^12}\t{:^8}\t{:^10}\t{:^10}\t{:^8}'
    print(format_title.format('id', '姓名', '语文成绩', '数学成绩', '英语成绩', '总成绩'))
    # 定义内容显示格式
    format_data = '{:^6}\t{:^12}\t{:^10}\t{:^12}\t{:^12}\t{:^10}'
    for item in lst:
        print(format_data.format(item.get('id'),
                                 item.get('name'),
                                 item.get('chinese'),
                                 item.get('math'),
                                 item.get('english'),
                                 int(item.get('chinese'))+int(item.get('math'))+int(item.get('english'))))
if __name__ == '__main__':
    main()

实操案例

1.案例一

"""
任务一：向文件输出“奋斗成就更好的你”
任务二：输出北京天气预报
任务三：输出图书勋章（带颜色）
任务四：输出你的身体指标
时间：2023/7/31 13:46
"""
# 任务一：向文件输出“奋斗成就更好的你”
## 方法一：
"""fp = open('test.txt', 'w')
print('奋斗成就更好的你', file=fp)
fp.close()"""

## 方法二：
"""fp = 'test.txt'
with open(fp, 'w', encoding='utf-8') as file:
    file.write('奋斗成就更好的你')"""

## 任务二：输出北京天气预报
"""print('星期一', '今天')
print('---------------------------------------')
print(' 08时', '11时', '14时', '17时','23时')
print('23°C', '26°C', '30°C', '30°C','23°C')
print('---------------------------------------')"""

## 任务三：输出图书勋章（带颜色）
"""
https://www.cnblogs.com/LY-C/p/9112720.html
"""
"""print('\033[0:35m\t\t图书勋章\033[m')"""

## 任务四：输出你的身体指标
height = 176
weight = 64
bmi = weight/(height+weight)
print('bmi指数为：', bmi)

2.案例二

无

3.案例三

"""
任务一：将指定的十进制数转化为二进制，八进制，十六进制
时间：2023/8/9 10:50
"""
# 任务一：将指定的十进制数转化为二进制，八进制，十六进制
def fuc():
    ## 二进制
    num = int(input('请输入一个十进制的整数！'))            #将str类型转为int类型
    print(num, '的二进制数为：', bin(num))                 #写法一
    print(str(num)+'的二进制数为：'+bin(num))              #写法二
    print("%s的二进制数为：%s"%(num, bin(num)))            #写法三
    print("{0}的二进制数为{1}".format(num, bin(num)))     #写法四
    print(f"{num}的二进制数为：{bin(num)}")                #写法五
    ## 八进制
    print(f'{num}的八进制数为：{oct(num)}')
    ## 十六进制
    print(f'{num}的十六进制数为：{hex(num)}')
while True:
    try:
        fuc()
        break
    except:
        fuc()

4.案例五

"""
任务一.猜数游戏
任务二.计算100-999之间的水仙花数
时间：2023/8/12 9:05
"""
# 任务一.猜数游戏
## 二分搜索算法(折半查找算法)
'''
https://blog.csdn.net/qq_51628741/article/details/122946882?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522169180336816800211558034%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=169180336816800211558034&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-122946882-null- null.142^v92^insert_down28v1&utm_term=%E4%BA%8C%E5%88%86%E6%90%9C%E7%B4%A2%E7%AE%97%E6%B3%95&spm=1018.2226.3001.4187
'''
import random
rand = random.randint(1, 100)
i = 0
"""while True:
    num = int(input('有一个1-100的整数，请你猜一猜！'))
    i = i+1
    if num < rand:
        print('猜小了！')
    elif num > rand:
        print('猜大了！')
    else:
        print('恭喜你，猜对了！')
        break
print(f'你猜了{i}次！')
if i < 3:
    print('您真是运气之王！')
elif i < 7:
    print('还行!')
else:
    print('有笨蛋!去学学二分搜索算法吧!')"""
## 使用二分查找算法找到随机数
'''i = 0
s = 0
e = 100
mid = (s+e)//2
while True:
    i = i+1
    if mid < rand:
        s = mid+1
        mid = (s+e)//2
    elif mid > rand:
        e = mid-1
        mid = (s+e)//2
    else:
        print(f'使用二分查找一共查找了{i}次！')
        break'''

# 任务二.计算100-999之间的水仙花数
import math
for i in range(100, 999):
    if math.pow((i%10), 3)+math.pow((i//10%10), 3)+math.pow(i//100, 3) == i:
        print(i)

5.案例六

"""
任务一：‘千年虫’我来了
任务二：京东购物流程
时间：2023/8/12 9:51
"""
# 任务一：‘千年虫’我来了
'''year = [82, 83, 82, 92, 00, 85]         # 00输出为0
print('原列表：', year)
for index, value in enumerate(year):
    # print(index, value)
    if str(value) != '0':
        year[index] = int('19'+str(value))
    else:
        year[index] = int('200'+str(value))
print('修改之后的列表：', year)
year.sort()
print('排序之后的列表为：', year)'''

# 任务二：京东购物流程
lst = []

## 方法一
'''
# 商品入库
print('商品入库，请输入商品信息，输入0时结束商品入库！')
while True:
    cno = input('请输入商品的编号：\n')
    cname = input('请输入商品的名称：\n')
    if cno == '0':
        break
    goods_dict = {'cno': cno, 'cname':cname}
    lst.append(goods_dict)
print(lst)

# 添加商品到购物车
cart = []
while True:
    num = input('请输入要添加购物车的编号，输入’q‘时退出选购')
    if num == 'q':
        break
    for item in lst:
        d = dict(item)
        if d['cno'] == num:
            cart.append(d)
            break
print('购物车中的商品为：', cart)'''

## 方法二
# 商品入库
for i in range(0, 5):
    goods = input('请输入商品编写和商品名称进入商品的入库，每次只能输入一件商品：\n')
    lst.append(goods)
for item in lst:
    print(item)

cart = []
while True:
    num = input('请输入要购买商品的编号：')
    for item in lst:
        if item.find(num) != -1:
            cart.append(item)
            break
    if num == 'q':
        break
print('您购物车中已经选好的商品为：')
# 逆序输出商品
for i in range(len(cart)-1, -1, -1):            # 注意步长为-1
    print(cart[i])

6.案例九

"""
任务一：统计字符串中出现指定字符的次数
时间：2023/8/12 11:01
"""
def count(s, ch):
    n = 0
    for i in s:
        if ch.upper() == i or ch.lower() == i:
            n = n+1
    return n
if __name__ == '__main__':
    s = 'dadadasafsfasdasfsdad'
    ch = input('请输入要统计的字符：')
    num = count(s, ch)
    print(f'字符{ch}在字符串{s}中出现的次数为：{num}次')

7.案例十二

"""
任务一：定义一个圆的类计算面积和周长
任务二：定义学生类录入5个学生信息存储到列表中
时间：2023/8/12 13:57
"""
# 任务一：定义一个圆的类计算面积和周长
"""import math
class Circle(object):
    def __init__(self, r):
        self.r = r

    def get_area(self):
        return math.pi*math.pow(self.r, 2)

    def get_perimeter(self):
        return 2*math.pi*self.r

if __name__ == '__main__':
    r = int(input('请输入圆的半径：'))
    c = Circle(r)
    print(f'圆的面积为：{c.get_area()}')
    print(f'圆的周长为：{c.get_perimeter()}')

    print('圆的面积为：{:.2f}'.format(c.get_area()))
    print('圆的周长为：{:.2f}'.format(c.get_perimeter()))"""

# 任务二：定义学生类录入5个学生信息存储到列表中
class Student(object):
    def __init__(self, stu_name, stu_age, stu_gender, stu_score):
        self.stu_name = stu_name
        self.stu_age = stu_age
        self.stu_gender = stu_gender
        self.stu_score = stu_score
    def show(self):
        print(self.stu_name, self.stu_age, self.stu_gender, self.stu_score)

if __name__ == '__main__':
    print('请输入五位学员的成绩信息：(姓名#年龄#性别#成绩)')
    lst = []
    for i in range(0, 5):
        s = input(f"请输入第{i+1}位学员的信息和成绩：")
        s_lst = s.split('#')                        # 把信息分割成列表
        # 创建学生对象
        stu = Student(s_lst[0], s_lst[1], s_lst[2], s_lst[3])
        lst.append(stu)
    #遍历列表
    for item in lst:
        item.show()

8.案例十三

"""
任务一：编写程序实现乐手弹奏乐器。乐手可以弹奏不同的乐器从而发出不同的声音。可以弹奏的乐器包括二胡，钢琴和琵琶
任务二：请使用面向对象的思想，设计自定义类，描述出租车和家用轿车的信息
时间：2023/8/12 14:49
"""
# 任务一：编写程序实现乐手弹奏乐器。乐手可以弹奏不同的乐器从而发出不同的声音。可以弹奏的乐器包括二胡，钢琴和琵琶
"""class Instrument(object):
    def make_sound(self):
        print('会发声！')

class Erhu(Instrument):                     #继承Instrument类
    def make_sound(self):
        print('二胡在演奏')

class Piano(Instrument):
    def make_sound(self):
        print('钢琴在演奏')

class Violin(Instrument):
    def make_sound(self):
        print('小提琴在演奏')

class Bird():                               #不继承Instrument类，只继承make_sound方法        
    def make_sound(self):
        print('小鸟在唱歌')

def play(instrument):
    instrument.make_sound()

if __name__ == '__main__':
    play(Erhu())
    play(Piano())
    play(Violin())
    play(Bird())"""

# 任务二：请使用面向对象的思想，设计自定义类，描述出租车和家用轿车的信息
class Car(object):
    def __init__(self, type, no):
        self.type = type
        self.no = no
    def start(self):
        pass
    def stop(self):
        pass

class Taxi(Car):
    def __init__(self, type, no, company):
        super().__init__(type, no)
        self.company = company
    def start(self):
        print('乘客您好')
        print(f'我是{self.company}出租车公司的，我的车牌号时{self.no},请问您要去哪里？')
    def stop(self):
        print('目的地到了！')

class FamilyCar(Car):
    def __init__(self, type, no, name):
        super().__init__(type, no)
        self.name = name
    def start(self):
        print('目的地到了我们去玩吧！')
    def stop(self):
        print(f'我是{self.name},我的汽车我做主！')
if __name__ == '__main__':
    taxi = Taxi('大众', '豫A6666', '河南客运')
    fcar = FamilyCar('byd', '豫A8888', '谷景涵')
    taxi.start()
    fcar.start()
    fcar.stop()
    taxi.stop()