python 查找一个整数的质因子并输出

文章目录

• python基础

• 一.python语法

• 1 几个概念

• 1.1 表达式
• 1.2 语句
• 1.3 程序
• 1.4 函数

• 2 标识符

• 2.1 关键字
• 2.2 标识符概念

• 二.变量

• 1 变量的概念
• 2 变量的运算

• 三.变量在内存中的原理

• 1. 引用变量
• 2.拷贝

• 四.运算符

• 1. 运算符

• 1.1 运算符的概念
• 1.2 运算符的分类
• 2. 算术运算符
• 3. 赋值运算符
• 4. 比较运算符
• 5. 逻辑运算符

• 5.1 not 逻辑非
• 5.2 and 逻辑与
• 5.3 or 逻辑或
• 5.4 非布尔值的与或运算

• 6. 条件运算符（三元运算符）
• 7. 运算符的优先级

• 第三讲作业

• 1.a,b=6,8 我想让a=8,b=6我该怎么办？
• 2.完成字符串的逆序以及统计
• 3.要求从键盘输入用户和密码，检验格式是否符合规则，如果不符合，打印出不符合的原因，并提示重新输入

• 第四讲作业

• 1.知识点写博客
• 2.练习课堂中老师敲的代码
• 3.以4种格式化字符串的方式来实现 521 xxx 嫁给我好吗？
• 4.现在有a b c三个变量，三个变量中分别保存有三个数值，请通过条件运算符获取三个值中的最大值

• 基本数据类型

• 一.整数和小数
• 二.布尔值和空值
• 三.字符串

• 1.什么是字符串
• 2.转义字符
• 3.长字符串
• 4.格式化字符串
• 5.字符串切片
• 6.字符串的其他操作

• 四.列表

• 1基本概念

• 1.1 序列（sequence）
• 1.2序列的分类
• 1.3列表(list)
• 1.4列表的使用
• 1.5切片
• 1.6通用操作
• 1.7修改列表
• 1.8列表的方法

• 五.元组

• 元组简介

• 六.字典

• 字典简介

• 1 字典的基本介绍
• 2 字典的使用
• 3 copy()
• 4 遍历字典

• 七.集合

• 1 集合简介
• 2 集合的运算

• 八.bytes类型

• 1 bytes介绍
• 2 bytes创建
• 3 bytes类型常用转换

• 九.可变类型和不可变类型
• 第七讲作业

• 1.课堂代码练习一遍
• 2. a = {"name":"123","data":{"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}} 找到python1/python2/python3
• 3.有如下值列表[11,22,33,44,55,66,77,88,99,90], 将所有大于66的值保存至字典的第一个key的值中，将小于66值保存至第二个key的值中。

• 流程控制

• 一.条件判断

• 1 条件判断语句(if语句)
• 2 input() 函数
• 3 if-else语句
• 4 if-elif-else 语句

• 二.循环控制

• 1.while语句
• 2.break和continue
• 3.for循环遍历

• for循环

• 4.range(start, stop[, step])

• 三.循环嵌套

• 循环嵌套

• 第五讲作业

• 1. 写博客
• 2. 练习课堂中老师敲的代码
• 3. 求1000以内所有的水仙花数
• 4. 获取用户输入的任意数，判断其是否是质数?
• 5. 猜拳游戏：

• 第六讲作业

• 1. 现在有 a = [1,2,3,4,5,6] 用多种方式实现列表的反转([6,5,4,3,2,1]) 并写出推导过程
• 2. 给 用户9次机会 猜1 - 10 个数字随机来猜数字。如果随机的数字和用户输入的数字一致则表示正确，如果不一致则表示错误。最终结果要求用户怎么也猜不对
• 3. 有两个列表 lst1 = [11, 22, 33] lst2 = [22, 33, 44]获取内容相同的元素
• 4. 现在有8位老师，3个办公室，要求将8位老师随机的分配到三个办公室中
• 5. 现在有8位老师，3个办公室，要求将8位老师随机的分配到三个办公室中，要求，每个办公室至少有一位老师。

python基础

一.python语法

1 几个概念

1.1 表达式

• 表达式，是由数字、算符、数字分组符号（括号）、自由变量和约束变量等以能求得数值的有意义排列方法所得的组合
• 表达式特点：
  一般仅计算一些结果，不会对程序产生实质性的影响
  在交互模式中输入一个表达式，解释器会自动将表达式的结果输出

示例

a = 1
b = 2
a + b
1 < 2
print('yangyu changes the world')

1.2 语句

• 一个语法上自成体系的单位，由一个词或句法上有关连的一组词构成
• 语句的执行一般会对程序产生一定的影响,在交互模式中不一定会输出语句的执行结果

示例

print('yangyu changes the world')  # 打印语句
input('请输入：')  # 输入语句

i = 3  # 在python中，你想要用的一个东西，要么它是python自带的，要么你从别的地方拿进来，要么你自己定义一个
if i > 2:  # 判断语句，当判断语句为True的时候，才会执行if语句后面的代码
    pass  # 语法占位，可以是语法变得完整，不会报错
print('yangyu is a good man')

1.3 程序

• 程序就是由一条一条的语句和一条一条的表达式构成的。

1.4 函数

函数就是一种语句，函数专门用来完成特定的功能

• 函数形如：xxx()

函数的分类：

• 内置函数： 或者内建函数，就是由语法规定存在的函数，这些函数，包含在编译器运行时的库中，程序员不必单独书写代码实现它，只需要调用既可。
• 自定义函数： 由程序员自己创建的函数。

当我们需要完成某个功能时，就可以去调用内置函数，或者自定义函数

函数的2个要素：参数 返回值.

示例

# 函数
print("yangyu changes the world")  # 内建函数，python自带


# 函数: 参数 返回值
def xxx(a, b):  # 自定义函数
    pass

2 标识符

2.1 关键字

• python中一些具有特殊功能的标识符，这就是所谓的关键字，关键字是python已经使用的了，不允许开发者自己定义和关键字相同名字的标识符

2.2 标识符概念

• 开发人员在程序中自定义的一些符号和名称。标识符是自己定义的,如变量名 、函数名等
• 组成：由26个英文字母大小写，数字 0-9 符号 _
• 标识符的规则：
  1.标识符中可以包含字母、数字、下划线_，但是不能使用数字开头 例如：name1 name_1 _name1 1name（不行）
  2.Python中不能使用关键字来作为标识符

Python 包含的关键字可以执行如下命令进行查看：

import keyword
print(keyword.kwlist)
'''
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await',
 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
  'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda',
   'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
'''

命名方式

• 驼峰命名法：
  小驼峰式命名法： 第一个单词以小写字母开始；第二个单词的首字母大写，例如：myName、aDog
  大驼峰式命名法： 每一个单词的首字母都采用大写字母，例如：FirstName、LastName
• 下划线_命名法：
  在程序员编程中还有一种命名法比较流行，就是用下划线“_”来连接所有的单词，比如 get_url buffer_size

二.变量

1 变量的概念

• 变量是计算机内存中的一块区域，存储规定范围内的值，值可以改变，通俗的说变量就是给数据起个名字。
• 变量命名规则：
  变量名由字母、数字、下划线_组成要符合标识符的命名规范
  不能以数字开头
  不能使用关键字
• 注意 :两个对象相等和两个对象是同一个对象是两个概念

import copy

s1 = {'yangyu': 'Python'}
s2 = copy.deepcopy(s1)
print(s2)  # {'yangyu': 'Python'}
print(id(s1), id(s2))  # 37747432 38426088
print(s1 == s2)  # True
a = 100000
b = 100000
print(id(a), id(b))  # 39658256 39658256 int类型在内存中是永恒不变的

• 在ipython中的内存比pycharm小，超过一定范围的数字类型，a=100000和b=100000就是不同的内存地址。

2 变量的运算

• 变量的运算就是正常的四则运算 ,需要注意的是在运算过程中含有浮点数，那么它返回的就是一个浮点数类型。整数除以整数会得到一个浮点数。

三.变量在内存中的原理

原理：变量在内存中就是一块特定的存储区域（地址）。

1. 引用变量

• 两个引用指向同一个int数据

a = 15
b = 15
print(id(a), id(b))  # 8791275373264 8791275373264
c = 15000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
d = 15000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
print(id(c), id(d))  # 37568224 37568224

结果：地址一样

• 两个引用指向同一个list数据

list1 = [1, 2, 3, 4, 5]
list2 = [1, 2, 3, 4, 5]
print(id(list1), id(list2))  # 33247752 33248264
list3 = ['a', 'b', 'c', 'd', 'e']
list4 = ['a', 'b', 'c', 'd', 'e']
print(id(list3), id(list4))  # 6469320 37627272

结果：地址不一样

2.拷贝

list1 = [1, 2, 3, 4, 5]
list2 = list1.copy()
print(id(list1), id(list2))  # 3887624 3888136
list3 = ['a', 'b', 'c', 'd', 'e']
list4 = list3.copy()
print(id(list3), id(list4))  # 34059912 34101832

结果：地址不一样

四.运算符

1. 运算符

1.1 运算符的概念

• 运算符用于执行程序代码运算，会针对一个以上操作数项目来进行运算。例如：2+3，其操作数是2和3，而运算符则是“+”

1.2 运算符的分类

• 算术运算符
• 赋值运算符
• 比较运算符（关系运算符）
• 逻辑运算符
• 条件运算符（三元运算符）

2. 算术运算符

• 加法运算符 表现形式 +
• 减法运算符 表现形式 -
• 乘法运算符 表现形式 *
• 除法运算符 表现形式 /
• // 整除，只会保留计算后的整数位，总会返回一个整型
• % 取模，求两个数相除的余数
• ** 幂运算，求一个值的几次幂

示例

a = 1 + 2
print(a)  # 3
a1 = '1' + '2'
print(a1)  # 12
print(type(a1))  # <class 'str'>
b = 1 - 2
print(b)  # -1
c = 1 * 3
c1 = "1" * 3
print(c)  # 3
print(c1)  # 111  本质上是 '1' + '1' + '1'
print(type(c1))  # <class 'str'>  字符串只能进行加、乘运算
d = 8 / 2
print(d)  # 4.0
e = 8 / 3
print(e)  # 2.6666666666666665
f = 8 // 5
print(f)  # 1
g = 8 % 5
print(g)  # 3
h = -10 % 3  # 向下取整原则，计算过程：r=-10-(-10/3)*3=-10-(-4*3)=2
print(h)  # 2
i = 10 % (-3)  # 向下取整原则，计算过程：r=10-(10/-3)*-3=10-(-4*-3)=-2
print(i)  # -2
g = 2 ** 3
print(g)  # 8

3. 赋值运算符

赋值运算符的特殊写法 x = x + 3 其实是和 x += 3 是一样的

• += （x+= 3 相当于 x = x + 3 ）
• -= （x -= 3 相当于 x= x - 3 ）
• *= (x *= 3 相当于 x = x * 3 ）
• **= （x **= 3 相当于 x = x ** 3 ）
• /= （x /= 3 相当于 x = x / 3 ）
• //= （x //= 3 相当于 x = x // 3 ）
• %= （x %= 3 相当于 x= x % 3 ）

x = 1
x += 3
print(x)  # 4

4. 比较运算符

• 比较运算符用来比较两个值之间的关系，总会返回一个布尔值.如果关系成立，返回True，否则返回False

> 比较左侧值是否大于右侧值

>= 比较左侧的值是否大于或等于右侧的值

< 比较左侧值是否小于右侧值

<= 比较左侧的值是否小于或等于右侧的值

• 特殊的比较方式
  == 比较两个对象的值是否相等
  != 比较两个对象的值是否不相等
  is 比较两个对象是否是同一个对象，比较的是对象的id
  is not 比较两个对象是否不是同一个对象，比较的是对象的id

示例

res1 = 2 > 1
res2 = 1 > 1
print(res1)  # True
print(res2)  # False
res3 = '1' > '2'
print(res3)  # False
res4 = '11' > '2'
print(res4)  # False 比较第1个数字在ASCII表中的大小  第1个比较出结果就不会比较第2个
res5 = '11' > '1'
print(res5)  # True 先比较第1个数字在ASCII表中的大小，第1个比较出结果相同然后比较第2个
res6 = '11' > '12'
print(res6)  # False 先比较第1个数字在ASCII表中的大小，第1个比较出结果相同然后比较第2个
res7 = '-1' > ''
print(res7)  # True  任何字符串都比空字符串大
res7 = '1' > ' '
print(res7)  # True  任何字符串都比空字符串大
res8 = 'aa' > 'ab'
print(res8)  # False
res8 = 'A' > 'a'
print(res8)  # False

字符串‘1’在ASCII为49，字符串‘2’在ASCII为50，所以’1’ > '2’返回结果为False

ord(‘1’),ord(‘2’)

(49, 50)

以下是ASCII表

特殊比较复杂示例

# == 比较两个对象的值是否相等
# != 比较两个对象的值是否不相等
# is 比较两个对象是否是同一个对象，比较的是对象的id
# is not 比较两个对象是否不是同一个对象，比较的是对象的id
res1 = 3 == 3
print(res1)  # True
res2 = 'yangyu' == 'yangyu'
print(res2)  # True
res3 = 1 == True  # bool Ture实际就是1的值，False实际就是0的值
print(res3)  # True
print(res3 + 1)  # 2
res4 = 1 is True
print(res4)  # False

5. 逻辑运算符

5.1 not 逻辑非

• not可以对符号右侧的值进行非运算，对于布尔值，非运算会对其进行取反操作，True变False，False变True

5.2 and 逻辑与

• and可以对符号两侧的值进行与运算。 只有在符号两侧的值都为True时，才会返回True，只要有一个False就返回False
• 与运算是找False的，如果第一个值为False，则不再看第二个值

5.3 or 逻辑或

• 或运算两个值中只要有一个True，就会返回True
• 或运算是找True的

5.4 非布尔值的与或运算

• 当我们对非布尔值进行与或运算时，Python会将其当做布尔值运算，最终会返回原值
• 非布尔值与运算的规则
  与运算是找False的，如果第一个值是False，则不看第二个值。如果第一个值是False，则直接返回第一个值，否则返回第二个值
• 非布尔值或运算的规则
  或运算是找True的，如果第一个值是True，则不看第二个值。如果第一个值是True，则直接返回第一个值，否则返回第二个值

示例：

# 逻辑非
'''
除了0 空值 None 和一些表示空性的值会转换为False，
其余的所有都可以转换为True:只能是进行逻辑True、False判断的时候'''
a = 1
a = not a
print(a)  # False
b = 1
b = not 0
print(b)  # True
c = 1
c = not None
print(c)  # True
d = 1
d = not ''
print(d)  # True
e = 1
e = not []
print(e)  # True
f = 1
f = not {}
print(f)  # True
g = 1
g = not ()
print(g)  # True

# 逻辑与and
res1 = True and True
print(res1)  # True
res2 = True and False
print(res2)  # False
res3 = False and False
print(res3)  # False

# 逻辑或
res4 = True or True
print(res4)  # True
res5 = True or False
print(res5)  # True
res6 = False or False
print(res6)  # False

# 逻辑与或好非布尔值运算
# 逻辑与: 规则是找False,如果第一个值为False，则不看第二个值，直接返回第一个值，反之则返回第二个值
res7 = 1 and 2
print(res7)  # 2
res8 = 1 and 0
print(res8)  # 0
res9 = 0 and 2
print(res9)  # 0
res9 = 0 and None
print(res9)  # 0

# 逻辑或：规则是找True,如果第一个值为True，则不看第二个值，直接返回第一个值，反之则返回第二个值
res10 = 1 or 2
print(res10)  # 1
res11 = 1 or 0
print(res11)  # 1
res12 = 0 or 2
print(res12)  # 2
res13 = 0 or None
print(res13)  # None
res14 = False or 0
print(res14)  # 0

6. 条件运算符（三元运算符）

条件运算符在执行时，会先对条件语句中的表达式进行求值判断
如果判断结果为True，则执行语句1，并返回执行结果
如果判断结果为False，则执行语句2，并返回执行结果
语法： 语句1 if 条件表达式 else 语句2

示例

# 条件运算符
a = 20
b = 30

# 语法： 语句1 if 条件表达式 else 语句2
c = a if b > a else b
print(c)  # 20

7. 运算符的优先级

运算符优先级参照表

示例

# 运算符的优先级
a = 2 + 3 * 4
print(a)  # 14
b = 2 or 3 and 4
# 假设or 和 and 优先级一样高，从左往右计算 结果是4
# 假设or优先级一样高于and，从左往右计算 结果是4
# 假设and优先级一样高于or，从右往左计算 结果是2
print(b)  # 2

c = 3
b = c or 4
print(b)  # 3

第三讲作业

1.a,b=6,8 我想让a=8,b=6我该怎么办？

# 第一种 使用中间变量
a = 6
b = 8
c = a
a = b 
b = c
print(a, b)


# 第二种 重新赋值法
a = 6
b = 8
a, b = b, a
print(a, b)

2.完成字符串的逆序以及统计

• 要求只能输入长度不低于31的字符串，否则提示用户重新输入
• 打印出字符串长度
• 使用切片逆序打印出字符串。

# 方法一
while True:
    input_str = input('请您输入长度不低于31位数的字符串:')
    if len(input_str) < 31:
        print('您输入的字符长度小于31，请你重新输入!')
    else:
        print('你输入的字符串长度为:' + str(len(input_str)))
        print('你输入的字符串逆序排序为:' + input_str[::-1])
        break
       
# 方法二
while True:
    str1 = input("请输入一个不少于31个字符的字符串：")
    num = len(str1)
    if num >= 31:
        print('你输入的字符串长度为:%s' % num)
        print(str1[::-1])
        break
    else:
        print('你输入的字符串长度为:%s，短了！请重新输入！' % num)

3.要求从键盘输入用户和密码，检验格式是否符合规则，如果不符合，打印出不符合的原因，并提示重新输入

• 用户名长度为6-20字符，用户名必须以字母开头
• 密码长度至少6位，不能为纯数字，不能有空格

# 方法1
while True:
    input_username = input("请输入用户名(以字母开头且长度为6-20个字符)：")
    if len(input_username) > 20 or len(input_username) < 6:
        print('您输入的用户名长度为%s字符，不符合要求，请重新输入' % len(input_username))
        continue
    elif input_username[0].isalpha() == False:
        print("您输入的用户名%s不是以字母开头，不符合要求，请重新输入" % input_username)
        continue
    else:
        while True:
            input_passwd = input("请输入密码：")
            if len(input_passwd) < 6:
                print("密码太短，您输入的密码为%s" % input_passwd)
            elif input_passwd.find(' ') != -1:
                print("密码中不能有空格，您输入的密码为%s" % input_passwd)
            elif input_passwd.isdigit() == True:
                print("密码格式错误，不能全部为数字。您输入的密码为%s。" % input_passwd)
            else:
                print("密码格式正确！ \n请牢记您的用户和密码" )
                break
    break

# 方法二
while True:
    input_username = input("请输入用户名(以字母开头且长度为6-20个字符)：")
    if len(input_username) > 20 or len(input_username) < 6:
        print('您输入的用户名长度为%s字符，不符合要求，请重新输入' % len(input_username))
        continue
    elif input_username[0].isalpha() == False:
        print("您输入的用户名%s不是以字母开头，不符合要求，请重新输入" % input_username)
        continue
    while True:
        input_passwd = input("请输入密码：")
        if not input_passwd.isdigit():
            if len(input_passwd) >= 6:
                if ' ' in input_passwd:
                    print("密码中不能有空格，您输入的密码为%s" % input_passwd)
                    continue
                else:
                    print("密码格式正确！ \n请牢记您的用户和密码")
                    break
            else:
                print("密码太短，您输入的密码为%s" % input_passwd)
                continue
        else:
            print("密码格式错误，不能全部为数字。您输入的密码为%s。" % input_passwd)
            continue
    break

第四讲作业

1.知识点写博客

2.练习课堂中老师敲的代码

3.以4种格式化字符串的方式来实现 521 xxx 嫁给我好吗？

# 以4种格式化字符串的方式来实现 521 xxx 嫁给我好吗？
# 1.拼串
print(str(521) + " " + "xxx" + " " + "嫁给我好吗？")
# 2.传参
s1 = 'xxx'
s2 = "嫁给我好吗？"
print(521, s1, s2)
# 3.%s
print("521 %s 嫁给我好吗？" % 'xxx')
# 4.f''
name = 'xxx'
print(f"521 {name} 嫁给我好吗？")
# 5.str.format()
str1 = "521 {} 嫁给我好吗？"
print(str1.format("xxx"))

4.现在有a b c三个变量，三个变量中分别保存有三个数值，请通过条件运算符获取三个值中的最大值

# 现在有a b c三个变量，三个变量中分别保存有三个数值，请通过条件运算符获取三个值中的最大值
a = 10
b = 20
c = 30
res = a if a > b else b
res_max = res if res > c else c
print(res_max)  # 30

max1 = (a if a > b else b) if (a if a > b else b) > c else c
print(max1)  # 30
max2 = a if a > b and a > c else (b if b > c else c )
print(max2)  # 30

基本数据类型

• 数据类型指的就是变量的值的类型，也就是可以为变量赋哪些值
  整数和小数
• 整数 : 所有整数 例如 : a = 1 b = 101 c =911 都是int类型
• 小数常量 : 所有小数 例如 a = 1.3 b=3.14 用float类型表示

一.整数和小数

# 整数 int  又称整型
# 小数 float 又称浮点型
# 使用type()来查看一个数据类型到底属于什么类型
print(type(1.0))  # <class 'float'>
print(type(1))  # <class 'int'>
print(1.0 + 1.0)  # 2.0
print(1 + 2.0)  # 3.0
print(4 / 2)  # 2.0
print(1.0 + 2.0)  # 3.0
# 布尔值 bool  True False
print(type(True))  # <class 'bool'>
print(type(False))  # <class 'bool'>
# None
print(type(None))  # <class 'NoneType'>

二.布尔值和空值

• 布尔: 只有2个值一个是True 一个是False
• None常量：只有一个数值就是None 也就是空值

三.字符串

1.什么是字符串

• 字符串是由数字、字母、下划线_组成的一串字符
• 注意
  单引号或双引号不能混合使用
  Python中用一对双引号或者一对单引号包裹的内容就是字符串

2.转义字符

• 转义字符是一种特殊的字符常量。转义字符以反斜线"\"开头,后跟一个或几个 字符。转义字符具有特定的含义,不同于字符原有的意义,故称“转义”字符
• \t 表示制表符
• \n 表示换行符
• \\表示反斜杠\
• \’表示一个单引号（’）
• \ ”表示 一个双引号（”）

示例1:

# 字符串
a = "yangyu changes the world"
b = 'yangyu'

# 转义
print("中国\n杨羽")
#  中国
#  杨羽
print("中国\t杨羽")  # 中国	杨羽

# 转义
c = 'C:\\news'  # C:\news
print(c)

# r''转义
c = r'C:\news'  # C:\news
print(c)

示例2：

3.长字符串

• 长字符串,又叫做文档字符串, 我们使用三重引号来表示一个长字符串’’’ ‘’’
• 三重引号可以换行，并且会保留字符串中的格式

# 长字符串
a = '''yangyu changes the world'''
b = """yangyu"""
print(type(a))  # <class 'str'>
print(type(b))  # <class 'str'>
# 第1个作用：多行注释
"""
b
c
"""
# 第2个作用：保留文档格式
b = '人生苦短，' \
    '我学python'
print(b)  # 人生苦短，我学python
c = '''
    人生苦短，
    我学python
    '''
print(c)
# 人生苦短，
# 我学python

4.格式化字符串

• 第一种格式化字符串 拼串
• 第二种格式化字符串 参数传递
• 第三种格式化字符串 占位符
  %s 字符串占位
  %f 浮点数占位
  %d 整数占位
• 第四种格式化字符串 f’{变量}’或f’xxx{变量}xxx’
  ‘xxx{}xxx’.format(‘xxx’)

示例

a = "yangyu changes the world"  # python 创建的时候，设定字符串是一个不可变量、不可更改的数据类型

# 格式化字符串
# 1.拼串
s = 'yangyu '
s1 = 'changes the world'
s2 = s + s1
print(s + s1)  # yangyu changes the world
print(s2)  # yangyu changes the world

# 2.参数的传递
print('s =', s)  # s = yangyu

# 占位符：就是通过占据字符串里的一个位置，然后供给别人使用
# %s表示用字符串占位  %d表示用用整数占位  %f表示用小数占位
print('这是%s为你打下的江山' % '朕')  # 这是朕为你打下的江山
print('这里是%d万人民币，请你离开我儿子' % 300)  # 这里是300万人民币，请你离开我儿子
print('国际黄金人民币报价%f元/g' % 363.83)  # 国际黄金人民币报价363.830000元/g
print('国际黄金人民币报价%.2f元/g' % 363.83)  # 国际黄金人民币报价363.83元/g

# format 方式占位 同样是通过{}来占位，不需要传递参数
name = 'yangyu'
str1 = f'{name}'
print(str1)  # yangyu
s = f'这是{name}的皇冠！'
print(s)  # 这是yangyu的皇冠！
n = '股民朋友请注意：{}'.format('股市有风险，入市请谨慎')
print(n)  # 股民朋友请注意：股市有风险，入市请谨慎
import random
hougong = ['皇后', '华妃', '丽妃', '咖妃', '沈贵人', '曹贵人', '欣常在', '安答应', '刘嫔妃']
shiqin = random.choice(hougong)
goodnight = '今晚朕翻的是{}的牌子！'.format(shiqin)
print(goodnight)  # 今晚朕翻的是刘嫔妃的牌子！

5.字符串切片

示例

str1 = 'abcdefg'
print(str1[:])  # abcdefg  取全部
print(str1[::])  # abcdefg  取全部
print(str1[0::1])  # abcdefg  取全部  默认起始值为0，默认取到结尾，默认步长为1，步长为正数，由左向右找，步长为负数，由右向左找。
print(str1[::-1])  # gfedcba  反向取全部
print(str1[0])  # a  取第1个
print(str1[:-1])  # abcdef 切片是一个左闭右开区间
print(str1[0:-1])  # abcdef 切片是一个左闭右开区间

6.字符串的其他操作

• len() 字符串的长度
• max() 最大值
• min() 最小值
• str.split()分割字符串
• str.join()拼接字符串
• str.find()查找字符串
• str.index()查找字符串
• str.replace() 替换字符串
• str.partition() 把字符串分割为三部分

去空格

• str.strip() 左右两边去空格
• str.lstrip() 去左边空格
• str.rstrip() 去右边空格

字符串大小写

• str.upper() 全部大写
• str.lower() 全部小写
• str.isalnum() 判断所有字符都是数字或者字母
• str.isalpha() 判断所有字符都是字母
• str.isdigit() 判断所有字符都是数字
• str.islower() 判断所有字符都是小写
• str.isupper() 判断所有字符都是大写
• str.istitle() 判断所有单词都是首字母大写，像标题
• str.isspace() 判断所有字符都是空白字符、\t、\n、\r

示例

a = "yangyu changes the world"
b = "yangyu changes the wor灭霸"
# len() 长度
print(len(a))  # 24
print(len(b))  # 24   一个汉字或者一个英文字母都看做是一个字符，所以长度相等
print("====================分隔线==========================")
# max()最大值 min()最小值
str_num = '12349567189'
print(max(str_num), min(str_num))  # 9 1
print("====================分隔线==========================")
# str.split()分割字符串
list1 = a.split(' ')  # 以空格分割字符串，分割后形成一个列表
print(list1)  # ['yangyu', 'changes', 'the', 'world']
print("====================分隔线==========================")
# str.join()拼接字符串
print(' '.join(list1))  # yangyu changes the world
print("====================分隔线==========================")
# str.find()查找字符串
res = a.find('o')
print(res)  # 20  位置从0开始，o的位置刚好是20
res1 = a.find('i')
print(res1)  # -1  没找到，返回-1
print("====================分隔线==========================")
res2 = a.index('o')
print(res2)  # 20  位置从0开始，o的位置刚好是20
res3 = a.index('i')
print(res3)  # index  没找到，报错  ValueError: substring not found
print("====================分隔线==========================")
# str.replace() 替换字符串
res4 = a.replace('a', 'b')
print(res4)  # ybngyu chbnges the world
print("====================分隔线==========================")
# str.partition() 把字符串分割为三部分，分割后形成一个元组
res5 = a.partition('changes')
print(type(res5))  # <class 'tuple'>
print(res5)  # ('yangyu ', 'changes', ' the world')
print("====================分隔线==========================")
# 去空格str.strip() 左右两边去空格  str.lstrip() 去左边空格  str.rstrip() 去右边空格
a = "             Yangyu Changes The World                "
print(a.strip())  # Yangyu Changes The World  字符串两端没有空格
print(a.lstrip())  # Yangyu Changes The World +         空格
print(a.rstrip())  #         空格        + Yangyu Changes The World
print("====================分隔线==========================")
# 字符串大小写   str.upper() 全部大写     str.lower() 全部小写
a = "Yangyu Changes The World"
print(a.upper())  # YANGYU CHANGES THE WORLD
print(a.lower())  # yangyu changes the world
print("====================分隔线==========================")
# str.isupper() 判断是不是大写
print(a.isupper())  # False
print(a.upper().isupper())  # True
print("====================分隔线==========================")
# str.islower() 判断是不是小写
print(a.islower())  # False
print(a.lower().islower())  # True
print("====================分隔线==========================")
a = 'Yangyu Changes The World'
b = "515151091"
c = "yangyu 515151091 hello"
d = "YangyuChangesTheWorld"
# str.isalnum() 判断所有字符都是数字或者字母
print(a.isalnum())  # False
print(b.isalnum())  # True
print(c.isalnum())  # False
print(d.isalnum())  # True
print("=========分隔符1==========")
# str.isalpha() 判断所有字符都是字母
print(a.isalpha())  # False
print(b.isalpha())  # False
print(c.isalpha())  # False
print(d.isalpha())  # True
print("=========分隔符2==========")
# str.isdigit() 判断所有字符都是数字
print(a.isdigit())  # False
print(b.isdigit())  # True
print(c.isdigit())  # False
print(d.isdigit())  # False
print("=========分隔符3==========")
# str.islower() 判断所有字符都是小写
print(a.islower())  # False
print(b.islower())  # False
print(c.islower())  # True
print(d.islower())  # False
print("=========分隔符4==========")
# str.isupper() 判断所有字符都是大写
print(a.isupper())  # False
print(b.isupper())  # False
print(c.isupper())  # False
print(d.isupper())  # False
print("=========分隔符5==========")
# str.istitle() 判断所有单词都是首字母大写，像标题
print(a.istitle())  # True
print(b.istitle())  # False
print(c.istitle())  # False
print(d.istitle())  # False
print("=========分隔符6==========")
# str.isspace() 判断所有字符都是空白字符、\t、\n、\r
print(a.isspace())  # False
print(b.isspace())  # False
print(c.isspace())  # False
print(d.isspace())  # False

四.列表

1基本概念

1.1 序列（sequence）

• 序列是Python中最基本的一种数据结构。序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引）并且序列中的数据会按照添加的顺序来分配索引
• 数据结构指计算机中数据存储的方式

1.2序列的分类

• 可变序列（序列中的元素可以改变）：例如 列表（list）
• 不可变序列（序列中的元素不能改变）：例如 字符串（str）元组（tuple）

1.3列表(list)

• 列表是Python中的一个对象
• 列表的作用
  列表中可以保存多个有序的数据
  列表是用来存储对象的对象

示例

# 五大数据类型：字符串，列表，元组，字典，集合
# list []
list1 = [True, None, 'yangyu', 18, [1, 2, 3]]
print(list1)
print(list1[4])
print(list1[4][2])
print(len(list1))
'''
[True, None, 'yangyu', 18, [1, 2, 3]]
[1, 2, 3]
3
5
'''

1.4列表的使用

• 列表的创建：通过[]来创建一个空列表

list1 = []

1.5切片

• 切片是指从现有列表中获得一个子列表
• 通过切片来获取指定的元素
• 语法: 列表[起始 : 结束 : 步长]
• 通过切片获取元素时,会包括起始位置的元素,不会包括结束位置的元素
• 起始位置和结束位置的索引可以不写
• 如果省略结束位置, 则会从当前的开始位置一直截取到最后
• 如果省略开始位置, 则会从第一个元素截取到结束的元素，但是不包括结束的元素
• 如果开始位置和结束位置都省略, 则会从第一个元素开始截取到最后一个元素
• 步长表示每次获取元素的间隔，默认是1(可以省略不写)
• 步长不能是0,但可以是负数

示例

#              索引1    索引2
# 切片的语法：[开始位置：结束位置：步长]  可以取到开头,不可取到结尾,步长即为元素之间的间距,默认是1,不能为0
# 索引值：   0        1        2       3
list1 = ['刘德华', '张学友', '黎明', '郭富城']
# 索引值：  -4       -3       -2      -1
print(list1[1:3])  # ['张学友', '黎明']
print(list1[-3:-1])  # ['张学友', '黎明']
print(list1[:])  # ['刘德华', '张学友', '黎明', '郭富城']  省略开头0和结尾，就默认取全部
print(list1[::])  # ['刘德华', '张学友', '黎明', '郭富城']  省略开头0和结尾，就默认取全部
print(list1[0:100])  # ['刘德华', '张学友', '黎明', '郭富城']  超出索引范围，也默认取全部
print(list1[::-1])  # ['郭富城', '黎明', '张学友', '刘德华']  逆序取全部
print(list1[-1:-3])  # []  步长为正数，向右取值，所以取值为空
print(list1[-1:-3:2])  # []  步长为正数，向右取值，所以取值为空
print(list1[-1:-3:-1])  # ['郭富城', '黎明']  步长为负数，向左取值

1.6通用操作

• + 和 *
• + 可以将两个列表拼接成一个列表
• * 可以将列表重复指定的次数 (注意2个列表不能够做乘法，要和整数做乘法运算)
• in用来检查指定元素是否在列表当中
• not in 用来检查指定元素是否不在列表当中
• len() 获取列表中元素的个数
• max() 获取列表中最大值
• min() 获取列表中最小值
• list.index(x[, start[, end]])
  第一个参数 获取指定元素在列表中的位置
  第二个参数 表示查找的起始位置
  第三个参数 表示查找的结束位置
• list.count(x) 统计指定元素在列表中出现的个数

示例

# 通用操作
list1 = [1, 2, 3] + [4, 5, 6]
print(list1)  # [1, 2, 3, 4, 5, 6]
list2 = [1, 2, 3] * 3
print(list2)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]
# in
print(1 in list1)  # True
# not in
print(1 not in list1)  # False
# max
print(max(list2))  # 3
# min
print(min(list2))  # 1
# list.index()
# name = 'yangyu'
# print(name.find('u'))  # 5 返回索引值5  没找到返回-1
# print(name.index('u'))  # 5 返回索引值5  没找到报错ValueError: substring not found
print(list2.index(2))  # 1 返回索引值1  从左往右找，只能找到第一个值的索引并返回出来，没找到报错ValueError: substring not found
list_str = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
index1 = list_str.index('e', 2, 7)
print(index1, list_str)  # 4 ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
index2 = list_str.index('c', 3, 7)
print(index2, list_str)  # ValueError: 'c' is not in list
# count
print(list2.count(2))  # 3 统计2在列表2中出现的次数

1.7修改列表

• 通过切片来修改(其实就是给切片的内容重新赋值，但是赋值的内容必须是一个序列)
• 当设置了步长时,序列中元素的个数必须和切片中元素的个数保持一致
• 通过切片来删除元素
• del list[起始 : 结束]
• list = []

示例

# 索引值：   0        1        2        3         4
list1 = ['刘德华', '张学友', '黎明', '郭富城', '周杰伦']
# 索引值：  -5       -4       -3       -2         -1
# 通过索引来修改，值必须是字符串
list1[0] = '李荣浩'
print('修改后', list1)  # 修改后 ['李荣浩', '张学友', '黎明', '郭富城', '周杰伦']
# del 关键字删除
del list1[0]
print('修改后', list1)  # 修改后 ['张学友', '黎明', '郭富城', '周杰伦']
# list1 = ['刘德华', '张学友', '黎明', '郭富城', '周杰伦']
# del list1[0:3]
# print('修改后', list1)  # 修改后 ['郭富城', '周杰伦']
# 通过切片来进行修改,值必须是列表
# list1[1:2] = '华晨宇'
# print('修改后', list1)   # 修改后 ['张学友', '华', '晨', '宇', '郭富城', '周杰伦']
list1[1:2] = ['华晨宇']
print('修改后', list1)   # 修改后 ['张学友', '华晨宇', '郭富城', '周杰伦']
list1[1:2] = [123, 456]
print('修改后', list1)   # 修改后 ['张学友', 123, 456, '郭富城', '周杰伦']
# list1[1::2] = ['yangyu']  # 取了两个数据出来，程序不知道替换哪一个
# print('修改后', list1)  # 报错ValueError: attempt to assign sequence of size 1 to extended slice of size 2
# list1[1::2] = ['yangyu', 'haiyan', 'huangrong']  # 取了两个数据出来，程序不知道怎样用三个数据替换两个数据
# print('修改后', list1)   # 报错ValueError: attempt to assign sequence of size 3 to extended slice of size 2
list1[1::2] = ['yangyu', 'haiyan']
print('修改后', list1)  # 修改后 ['张学友', 'yangyu', 456, 'haiyan', '周杰伦']
# 当我们通过切片来进行元素的替换时，如果使用了绝对值不是1的步长，那么你取了多少个数据就要用多少个数据替换

1.8列表的方法

• list.append() 向列表的最后添加一个元素
• list.insert(arg1,arg2) 向列表指定位置插入一个元素 参数1:要插入的位置 参数2:要插入的元素
• list.extend(iterable) 使用一个新的序列来扩展当前序列(它会将该序列的中元素添加到列表中) 参数需要传递一个序列
• list.pop() 根据索引删除并返回指定元素
• list.remove() 删除指定元素 (如果相同值的元素有多个，只会删除第一个)
• list.reverse() 反转列表
• list.sort(key=None,reverse=False) 用来对列表中的元素进行排序 reverse：True反序；False 正序

示例1

# 列表中的修改方法
# 索引值：   0        1        2        3         4
list1 = ['刘德华', '张学友', '黎明', '郭富城', '周杰伦']
# 索引值：  -5       -4       -3       -2         -1
# 添加方法
# list.append 添加 向列表最后添加一个元素
list1.append("李荣浩")
print("修改后", list1)  # 修改后 ['刘德华', '张学友', '黎明', '郭富城', '周杰伦', '李荣浩']
# list.insert 插入 向列表中某个位置插入一个元素
list1.insert(4, 'yangyu')
print("修改后", list1)  # 修改后 ['刘德华', '张学友', '黎明', '郭富城', 'yangyu', '周杰伦', '李荣浩']
# list.extend 扩展其他列表
list1.extend([1, 2, 3])
print("修改后", list1)  # 修改后 ['刘德华', '张学友', '黎明', '郭富城', 'yangyu', '周杰伦', '李荣浩', 1, 2, 3]

# 删除方法
# list.pop 根据索引值删除并且返回删除的数据，如果没有索引值，那么会默认删除最后一个
res = list1.pop(1)
print("修改后", list1)  # 修改后 ['刘德华', '黎明', '郭富城', 'yangyu', '周杰伦', '李荣浩', 1, 2, 3]
print(res)  # 张学友
res1 = list1.pop()  # 默认删除列表最后一个元素
print("修改后", list1)  # 修改后 ['刘德华', '黎明', '郭富城', 'yangyu', '周杰伦', '李荣浩', 1, 2]
print(res1)  # 3
# list.remove 根据指定元素来删除,如果元素不存在则报错ValueError: list.remove(x): x not in list
res2 = list1.remove('yangyu')
print(res2)  # None
print("修改后", list1)  # 修改后 ['刘德华', '黎明', '郭富城', '周杰伦', '李荣浩', 1, 2]

示例2

list3 = ['刘德华', '张学友', '黎明', '郭富城', '周杰伦', '刘德华', '张学友']
res3 = list3.remove('刘德华')  # 只能删除从左边开始找到的第一个元素
print("修改后", list3)  # 修改后 ['张学友', '黎明', '郭富城', '周杰伦', '刘德华', '张学友']

示例3

# list.reverse 列表反转
list4 = ['刘德华', '张学友', '黎明', '郭富城', '周杰伦']
list4.reverse()
print(list4)  # ['周杰伦', '郭富城', '黎明', '张学友', '刘德华']

# sort 进行排序  # unicode编码的中文是按《康熙字典》的偏旁部首和笔画数来排列的
list4.sort()
print(list4)  # ['刘德华', '周杰伦', '张学友', '郭富城', '黎明']
list4.sort(reverse=False)
print(list4)  # ['刘德华', '周杰伦', '张学友', '郭富城', '黎明']
list4.sort(reverse=True)
print(list4)  # ['黎明', '郭富城', '张学友', '周杰伦', '刘德华']

list5 = ["apple", "egg", "car", "dog"]  # 英文按照字符顺序排序
list5.sort(reverse=False)
print(list5)   # ['apple', 'car', 'dog', 'egg']
list5.sort(reverse=True)
print(list5)   # ['egg', 'dog', 'car', 'apple']

list6 = ["8", "5", "7", "9"]  # 字符串的数字也是按数字顺序排序
list6.sort(reverse=False)
print(list6)   # ['5', '7', '8', '9']
list6.sort(reverse=True)
print(list6)   # ['9', '8', '7', '5']

# 将字符串转为列表再进行排序
list7 = list("sdefrgthyjcuvibnmkl")
list7.sort(reverse=False)
print(list7)  # ['b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'r', 's', 't', 'u', 'v', 'y']
# list.clear()清空列表
list7.clear()
print(list7)  # []

五.元组

元组简介

• 元组表现形式 tuple
• 元组是一个不可变序列(一般当我们希望数据不改变时，我们使用元组，其他情况下基本都用列表)
• 使用()创建元素
• 元组不是空元组至少有一个逗号(,) 当元组不是空元组时括号可以省略
• 元组解包指将元组当中的每一个元素都赋值给一个变量

示例

# 元组 tuple ()
tuple1 = (1, 2, True, 4, 5)  # 对于这种不可变的数据，我们通常称它为常量
print(tuple1, type(tuple1))  # (1, 2, True, 4, 5) <class 'tuple'>
print(tuple1[1:3])  # (2, True)
# 如果你创建的不是一个空元组，那么它里面至少要有一个","，当你只做一个变量的赋值的时候，元组的括号可以省略
tuple2 = (10)
print(type(tuple2))  # <class 'int'>
tuple3 = ()
print(type(tuple3))  # <class 'tuple'>
tuple4 = (10,)
print(type(tuple4))  # <class 'tuple'>
tuple5 = 10,
print(type(tuple5))  # <class 'tuple'>
tuple6 = 10, 20
print(type(tuple6))  # <class 'tuple'>
# 元组的拆包
tuple7 = (1, 2, 3, 4)
a, b, c, d = tuple7
print(a, b, c, d)  # 1 2 3 4
# a, b, = tuple7  # 报错ValueError: too many values to unpack (expected 2)
# a, b, c, d, e = tuple7  # 报错ValueError: not enough values to unpack (expected 5, got 4)
a, *b = tuple7  # *号表示匹配所有,注意：不能同时存在两个或两个以上的*
print(a)  # 1
print(b)  # [2, 3, 4]
a, *b, c = tuple7
print(a)  # 1
print(b)  # [2, 3]
print(c)  # 4

六.字典

字典简介

1 字典的基本介绍

• 字典属于一种新的数据结构称为映射(mapping)
• 字典的作用和列表类似，都是用来存储对象的容器
• 列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反
• 在字典中每一个元素都有唯一的名字，通过这个唯一的名字可以找到指定的元素
• 这个唯一的名字，我们称之为key， 通过key可以快速查询value， value称之为值
• 字典我们也称之为键值对(key-value)结构
• 每个字典中都可以有多个键值对，而每一个键值对我们称其为一项(item)
• 创建一个有数据的字典,语法 {key:value}
• 字典的值可以是任意对象,字典的键可以是任意的不可变对象(int str bool tuple…)
• 字典的键是不能重复的，如果出现重复的后面的会替换前面的

2 字典的使用

• dict()函数来创建字典
• dict.get(key[,default]) 根据键来获取字典的值。第二个参数可以指定一个默认值，当获取不到值的时候会返回默认值
• dict.update() 将其他字典的key-value添加到当前的字典当中
• del 删除字典中的key-value
• dict.popitem() 删除字典最后的一个key-value 这个方法是有返回值的。删除之后它会将删除的key-value作为返回值返回
• dict.pop(key[,default]) 根据key删除指定中的value。第二个参数可以指定一个值，当获取不到值的时候会返回默认值

示例

# 字典的介绍
# 字典的对应关系   名称：数据  mapping映射关系 key:value {key:value} dict表示
# 创建字典的方式1
dict1 = {}
print(type(dict1))  # <class 'dict'>

# 一个key-value数据，我们称为一组数据，也叫它一项或键值对，用item表示
dict2 = {'name': "yangyu", "age": 18, '性别': '男'}

# 创建字典的方式2
# dict()
dict3 = dict(name="yangyu", age=18, 性别="男", 爱好=['study', 'python'], 朋友=('tom', 'jerry'), 简介=dict2)
print(dict3)
# {'name': 'yangyu', 'age': 18, '性别': '男', '爱好': ['study', 'python'], '朋友': ('tom', 'jerry'), '简介': {'name': 'yangyu', 'age': 18, '性别': '男'}}
# 字典特性：当有相同的key名称时，后面的键值会把前面的值覆盖掉
dict4 = {'name': "yangyu", "age": 18, '性别': '男', 'name': "king"}
print(dict4)  # {'name': 'king', 'age': 18, '性别': '男'}
dict5 = {'name': "yangyu", "age": 18, '性别': '男'}
dict5 = {'name': "yangyu", "age": 20, '性别': '男'}
print(dict5)  # {'name': 'yangyu', 'age': 20, '性别': '男'}

# 创建字典的方式3
dict6 = dict([('name', 'yangyu大帝'), ('age', 18)])
print(dict6)  # {'name': 'yangyu大帝', 'age': 18}
# 双值子序列都可以使用这种方式来创建字典  [(1,2), (3,4)]
# 双值序列[1,2] 'ab' (1,2)
# 子序列[(1,2)]

# 通常这样书写字典：
dict7 = {
            'name': "yangyu",
            "age": 20,
            '性别': '男',
            '爱好': 'python'
}
# 怎样获取字典里面的值？
print(dict7['爱好'])  # python

示例2

# 字典的增删改查
dict1 = {
            'name': "yangyu",
            "age": 20,
            '性别': '男',
            '爱好': 'python'
}
print(len(dict1))  # 4
print('name' in dict1)  # True
print('yangyu' in dict1)  # False
# 查询
print(dict1['name'])  # yangyu
# dict1.get() 当使用get查询不存在的key的时候，不会报错，会返回一个None
print(dict1.get("爱好"))  # python
# print(dict1['woman'])  # 这种方式查询不存在的key的时候，报错KeyError: 'woman'
print(dict1.get("woman"))  # None
# 修改
dict1['name'] = 'yangyu大帝'
print(dict1)  # {'name': 'yangyu大帝', 'age': 20, '性别': '男', '爱好': 'python'}
# dict.setdefault(key, value) 向字典中添加key-value，如果这个key存在，则不会做任何改变，如果不存在，直接添加进去。
dict1.setdefault('name', 'yangyu')
print(dict1)  # {'name': 'yangyu大帝', 'age': 20, '性别': '男', '爱好': 'python'}
dict1.setdefault('座右铭', 'yangyu is a good man')
print(dict1)  # {'name': 'yangyu大帝', 'age': 20, '性别': '男', '爱好': 'python', '座右铭': 'yangyu is a good man'}
# 在python2中分为有序字典和无序字典
# update()
dict2 = {'1': 1}
dict1.update(dict2)
print(dict1)  # {'name': 'yangyu大帝', 'age': 20, '性别': '男', '爱好': 'python', '座右铭': 'yangyu is a good man', '1': 1}

# del 关键字删除
del dict1["1"]
print(dict1)  # {'name': 'yangyu大帝', 'age': 20, '性别': '男', '爱好': 'python', '座右铭': 'yangyu is a good man'}
# dict.popitem()  删除最后一个键值对
res = dict1.popitem()
print(res)  # ('座右铭', 'yangyu is a good man')
print(dict1)  # {'name': 'yangyu大帝', 'age': 20, '性别': '男', '爱好': 'python'}
# dict.pop()
dict1.pop('age')
print(dict1)  # {'name': 'yangyu大帝', '性别': '男', '爱好': 'python'}
res1 = dict1.pop('age', '当前数据不存在')
print(dict1)
print(res1)  # 当前数据不存在
# dict.clear()
dict1.clear()
print(dict1)  # {}

3 copy()

copy() 方法用来对字典进行浅复制
注意:浅复制只会复制字典本身，如果字典中还有个字典是不会进行复制的

• 浅拷贝1

# 浅拷贝
# copy
a = 'str1'
b = 'str1'
print(id(a), id(b))  # 7615152 7615152 地址相同
c = 2
d = 2
print(id(c), id(d))  # 8791551476016 8791551476016 地址相同
dict1 = {
    'a': 1,
    'b': 2
}
# 浅拷贝
dict2 = {
    'a': 1,
    'b': 2
}
print(id(dict1), id(dict2))  # 7613880 7613960  地址不同
# 浅拷贝方式1
dict3 = dict1.copy()
print(id(dict1), id(dict3))  # 7613880 7618952 地址不同
# 浅拷贝方式2
import copy
dict4 = copy.copy(dict1)
print(id(dict1), id(dict4))  # 7613880 7619192 地址不同

• 浅拷贝2

import copy
dict1 = {
    'a': 1,
    'b': [1, 2, 3]
}
dict2 = copy.copy(dict1)
print(id(dict1), id(dict2))  # 37957128 37957208  地址不同（字典为可变变量）
print(id(dict1['a']), id(dict2['a']))  # 8791551475984 8791551475984 内部不可变变量地址相同
print(id(dict1['b']), id(dict2['b']))  # 37114376 37114376 内部可变变量地址相同
dict1['a'] = 5   # 修改dict1中不可变变量的value值，dict2不会跟着改变
print(dict1, dict2)  # {'a': 5, 'b': [1, 2, 3]} {'a': 1, 'b': [1, 2, 3]}
dict1['b'][0] = 10   # 修改dict1中可变变量的value值，dict2也会跟着改变
print(dict1, dict2)  # {'a': 5, 'b': [10, 2, 3]} {'a': 1, 'b': [10, 2, 3]}

• 深拷贝

# 深拷贝
import copy
dict1 = {
    'a': 1,
    'b': [1, 2, 3]
}
dict2 = copy.deepcopy(dict1)
print(id(dict1), id(dict2))  # 37629448 37634440  地址不同（字典为可变变量）
print(id(dict1['a']), id(dict2['a']))  # 8791328522512 8791328522512 内部不可变变量地址相同
print(id(dict1['b']), id(dict2['b']))  # 33116680 33117192 内部可变变量地址不同
dict1['a'] = 5  # 修改dict1中不可变变量的value值，dict2不会跟着改变
print(dict1, dict2)  # {'a': 5, 'b': [1, 2, 3]} {'a': 1, 'b': [1, 2, 3]}
dict1['b'][0] = 10   # 修改dict1中可变变量的value值，dict2也不会跟着改变
print(dict1, dict2)  # {'a': 5, 'b': [10, 2, 3]} {'a': 1, 'b': [1, 2, 3]}
# 应用场景，当你要对数据进行修改的时候，你又不想修改原来的数据，那么就需要用到深拷贝或者浅拷贝

4 遍历字典

我们主要可以通过3种方式对字典进行遍历

• dict.keys() 该方法返回字典所有的key
• dict.values() 该方法返回一个序列 序列中保存有字典的值
• dict.items() 该方法会返回字典中所有的项 它返回一个序列，序列中包含有双值子序列 双值分别是 字典中的key和value

# 遍历字典
# dict.keys()  获取字典中所有的键
dict1 = {'name': "yangyu", "age": 20, '性别': '男', '爱好': 'python'}
print(dict1.keys())  # dict_keys(['name', 'age', '性别', '爱好']) 返回的是一个序列
# dict.values()  获取字典中所有的值
print(dict1.values())  # dict_values(['yangyu', 20, '男', 'python']) 返回的是一个序列
# dict.items()  获取字典中所有的键值对
print(dict1.items())  # dict_items([('name', 'yangyu'), ('age', 20), ('性别', '男'), ('爱好', 'python')]) 返回的是一个序列
# 遍历字典
for k, v in dict1.items():
    print(k, ":", v)
'''
name : yangyu
age : 20
性别 : 男
爱好 : python
'''

七.集合

1 集合简介

• 集合表现形式set 集合和列表非常相似
• 不同点：
  集合只能存储不可变对象
  集合中存储的对象是无序的
  集合不能出现重复元素
• 使用{}来创建集合
• 可以通过set()来将序列和字典转换成集合
• 可以使用len()来获取集合中元素的数量
• set.add()像集合中添加元素
• set.update()将一个集合中的元素添加到另一个集合当中
• set.pop()随机删除集合中的一个元素,一般是删除最后一个元素
• set.remove() 删除集合中指定的元素
• set.clear() 清空集合

示例1

# 集合简介
# 1.集合只能存储不可变对象
# 2.集合中存储的对象是无序的
# 3.集合不能出现重复元素
# set表示集合 {}
# set1 = {[1, 2, 3]}
# print(set1)  # 报错TypeError: unhashable type: 'list'，因为列表是可变类型

set1 = {6, 8}
print(set1)  # {8, 6}   无序性
# print(set1[0])  # 报错 TypeError: 'set' object is not subscriptable
set2 = {3, 5, 4, 3, 5, 7, 6, 8}
print(set2)  # {3, 4, 5, 6, 7, 8}  去重

set3 = {}  # 创建空字典
print(type(set3))  # <class 'dict'>
set4 = set()  # 创建空集合
print(type(set4))  # <class 'set'>
tuple1 = ()  # 创建空元组，没有意义， 因为它不可变
print(type(tuple1))  # <class 'tuple'>

# 强制转换为集合的业务场景：去重
list1 = [1, 2, 3, 4, 2, 2, 3, 4, 5]
set5 = set(list1)
print(set5)  # {1, 2, 3, 4, 5}
list1 = list(set5)
print(list1)  # [1, 2, 3, 4, 5]

示例2

# 集合的使用
set1 = set()
print(set1)  # set()
set1.add(1)
print(set1)  # {1}
# set.update()将一个集合中的元素添加到另一个集合当中
set2 = {2, 3}
set1.update(set2)
print(set1)  # {1, 2, 3}
print(len(set1))  # 3
print(2 in set1)  # True
res = set1.pop()  # 随机删除一个元素
print(res)  # 1
print(set1)  # {2, 3}
# del set1[0]  # TypeError: 'set' object doesn't support item deletion
set1.remove(2)  # 删除集合中指定的元素
print(set1)  # {3}
set2 = set1.copy()  # 复制
print(set2)  # {3}
set1.clear()  # 清空set1内部元素
print(set1)  # set()
del set1   # 删除set1
print(set1)  # 因为set1已经删除，所以报错NameError: name 'set1' is not defined

2 集合的运算

• & 交集运算
• | 并集运算
• - 差集运算
• ^ 异或集
• <= 检查一个集合是否是另一个集合的子集
• < 检查一个集合是否是另一个集合的真子集
• >=检查一个集合是否是另一个集合的超集
• >检查一个集合是否是另一个集合的真超集

示例

# 集合的运算
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
# 交集 查看重复元素
print(set1 & set2)  # {4, 5}
# 并集 去重
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7, 8}
# 异或集
print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}
set3 = {1, 2, 3, 4, 5}
set4 = {1, 2, 3, 4, 5, 6, 7, 8}
# <= 检查一个集合是否是另一个集合的子集
print(set3 <= set4)  # True
# < 检查一个集合是否是另一个集合的真子集
print(set3 < set4)  # True
# >=检查一个集合是否是另一个集合的超集
print(set4 >= set3)  # True
# >检查一个集合是否是另一个集合的真超集
print(set4 > set3)  # True

八.bytes类型

1 bytes介绍

在Python3以后，字符串和bytes类型彻底分开了。字符串是以字符为单位进行处理的，bytes类型是以字节为单位处理的。
bytes数据类型在所有的操作和使用甚至内置方法上和字符串数据类型基本一样，也是不可变的序列对象。
Python3中，bytes通常用于网络数据传输、二进制图片和文件的保存等等。

2 bytes创建

可以通过调用bytes()生成bytes实例，其值形式为 b’xxxxx’，对于同一个字符串如果采用不同的编码方式生成bytes对象，就会形成不同的值。

a = b'yangyu'
print(type(a))  # <class 'bytes'>

b = bytes('yangyu changes the world', encoding='utf8')
print(type(b))  # <class 'bytes'>

3 bytes类型常用转换

那在实际应用中，我们通常会将bytes类型与str类型做转换。

• 字节转为字符串

d = b'yangyu'
e = d.decode()
print(e)  # yangyu
print(type(e))  # <class 'str'>
print(type(d))  # <class 'bytes'>

• 字符串转为字节

f = 'yangyu'
g = f.encode()
print(type(g))  # <class 'bytes'>

九.可变类型和不可变类型

• 可变类型： 列表 字典 集合 值改变，id不改变
• 不可变类型： 字符串 元组 值改变，id就改变

# 可变类型： 列表  字典  集合  值改变，id不改变
list1 = [1, 2, 3, 4]
print(id(list1))  # 3887624
list1.remove(2)
print(list1, id(list1))  # [1, 3, 4] 3887624

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4,}
print(id(dict1))  # 34287112
del dict1['a']
print(dict1, id(dict1))  # {'b': 2, 'c': 3, 'd': 4} 34287112

set1 = {1, 2, 3, 4, 5}
print(id(set1))
set1.remove(1)  # 40653544
print(set1, id(set1))  # {2, 3, 4, 5} 40653544

# 不可变类型： 字符串 元组  值改变，id就改变
a = 'ab'
print(id(a))  # 46068720
a = a + 'c'
print(a, id(a))  # abc 42134192
# 元组本身不可改变，但是可以通过修改里面的列表、字典、集合等可变变量
tuple1 = (1, 2, True, [4, 5])
print(id(tuple1))  # 601913528
tuple1[3][0] = 3
print(tuple1, id(tuple1))  # (1, 2, True, [3, 5]) 601913528

第七讲作业

1.课堂代码练习一遍

2. a = {“name”:“123”,“data”:{“result”:[{“src”:“python1”},{“src”:“python2”},{“src”:“python3”}]}} 找到python1/python2/python3

# 方法1
a = {"name": "123", "data": {"result": [{"src": "python1"}, {"src": "python2"}, {"src": "python3"}]}}
b = a.get("data")
print(b)
c = b.get("result")
print(c)
for i in c:
    print(i.get('src'))
'''
{'result': [{'src': 'python1'}, {'src': 'python2'}, {'src': 'python3'}]}
[{'src': 'python1'}, {'src': 'python2'}, {'src': 'python3'}]
python1
python2
python3
'''
# 方法2
a = {"name": "123", "data": {"result": [{"src": "python1"}, {"src": "python2"}, {"src": "python3"}]}}
print(a["data"]["result"][0]["src"])
print(a["data"]["result"][1]["src"])
print(a["data"]["result"][2]["src"])
'''
python1
python2
python3
'''

3.有如下值列表[11,22,33,44,55,66,77,88,99,90], 将所有大于66的值保存至字典的第一个key的值中，将小于66值保存至第二个key的值中。

# 方法1： 将列表进行升序排序，找出66的索引位置，然后进行切片
# [11,22,33,44,55,66,77,88,99,90], 将所有大于66的值保存至字典的第一个key的值中，将小于66的值保存至第二个key的值中。
list1 = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
list1.sort()     # 升序排序
index1 = list1.index(66)  # 获取 66的索引位置
value1 = list1[index1+1::]  # 大于66的值
value2 = list1[0:index1]    # 小于66的值
dict1 = dict([('key1', value1), ('key2', value2)])
print(dict1)
# {'key1': [77, 88, 90, 99], 'key2': [11, 22, 33, 44, 55]}

# 方法2：使用while循环
list1 = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
value3 = []
value4 = []
i = 0
while i < len(list1):
    if list1[i] > 66:
        value3.append(list1[i])
    elif list1[i] == 66:
        pass
    else:
        value4.append(list1[i])
    i += 1
dict2 = dict([('key1', value3), ('key2', value4)])
print(dict2)
# {'key1': [77, 88, 99, 90], 'key2': [11, 22, 33, 44, 55]}

# 方法3： 使用for循环
list1 = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
value3 = []
value4 = []

for i in list1:
    if i > 66:
        value3.append(i)
    elif i == 66:
        pass
    else:
        value4.append(i)
dict2 = dict([('key1', value3), ('key2', value4)])
print(dict2)  # {'key1': [77, 88, 99, 90], 'key2': [11, 22, 33, 44, 55]}

# 方法4是对方法3的简写
# [11,22,33,44,55,66,77,88,99,90], 将所有大于66的值保存至字典的第一个key的值中，将小于66的值保存至第二个key的值中。
list1 = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
key_1 = [i for i in list1 if i > 66]
key_2 = [j for j in list1 if j < 66]
dict1 = {"key_1": key_1, "key_2": key_2}
print(dict1)
# {'key_1': [77, 88, 99, 90], 'key_2': [11, 22, 33, 44, 55]}

流程控制

一.条件判断

1 条件判断语句(if语句)

• 执行的流程：
  if语句在执行时，会先对条件表达式进行求值判断，
  如果为True，则执行if后的语句
  如果为False，则不执行
  语法：
  if 条件表达式 :
          代码块
• 代码块中保存着一组代码，同一个代码块中的代码，要么都执行要么都不执行
• 代码块以缩进开始，直到代码恢复到之前的缩进级别时结束
• 代码块就是一种为代码分组的机制

示例：

# input接收到的数据一定是一个字符串，要想和int类型进行比较，一定要进行类型转换
a = int(input('请输入123三个数字的其中一个:'))# int()将字符串强制转换为int类型
if a == 1:
    print('您输入的数字是1')
if a == 2:
    print('您输入的数字是2')
if a == 3:
    print('您输入的数字是3')

num = 15
if 10 < num < 30:
    print("%s在10和30之间" % num)

2 input() 函数

• 该函数用来获取用户的输入
• input()调用后，程序会立即暂停，等待用户输入
• 用户输入完内容以后，点击回车程序才会继续向下执行
• 用户输入完成以后，其所输入的的内容会以返回值的形式返回

示例：

print(111111)
input()    # 阻塞程序，等待用户输入，输入后继续执行
print(222222)

3 if-else语句

• 语法：
  if 条件表达式 :
          代码块
  else :
          代码块
• 执行流程：
  if-else语句在执行时，先对if后的条件表达式进行求值判断
  如果为True，则执行if后的代码块
  如果为False，则执行else后的代码块)

示例

passwd = int(input('请输入解锁密码:'))
if passwd == 12345:
    print('您输入的密码正确')
else:
    print("您输入的密码不正确")

if-elif-else 语句 和 if-else 语句 一样，永远都有一个代码块会执行，代码时从上往下进行判断，如果没有True的条件表达式，执行else后面的代码块。

4 if-elif-else 语句

# if-elif-else 语句
value = 1000
if value >= 30000:
    print('有钱任性')
elif value >= 20000:
    print('有钱真好')
elif value >= 10000:
    print('哥也月薪上万了')
elif value >= 5000:
    print('工资还说的过去')
elif value >= 2000:
    print('能养活自己了')
else:
    print('吃土去吧！')

• 语法：
  if 条件表达式 :
          代码块
  elif 条件表达式 :
          代码块
  elif 条件表达式 :
          代码块
  …
  else :
          代码块
• 执行流程：
  if-elif-else语句在执行时，会自上向下依次对条件表达式进行求值判断，
  如果表达式的结果为True，则执行当前代码块，然后语句结束
  如果表达式的结果为False，则继续向下判断，直到找到True为止
  如果所有的表达式都是False，则执行else后的代码块
• 总结： if-elif-else中只会有一个代码块会执行

练习

# 指定输入的月份是什么季节
month = float(input("请输入月份："))
print("你输入的月份是%s" % month)
if 0 <= month <= 12:
    if 3 <= month <= 5:
        print('春季')
    elif 6 <= month <= 8:
        print('夏季')
    elif 9 <= month <= 11:
        print('秋季')
    else:
        print('冬季')
else:
    print("你输入的怕是火星上的月份吧！")

二.循环控制

1.while语句

• 循环语句可以使指定的代码块重复指定的次数.循环语句分成两种，while循环 和 for循环
• 语法：
  while 条件表达式 :
      代码块
  else：
      代码块

示例1

# while 循环语句
while True:
    print("yangyu")  # 死循环，不停打印yangyu

示例2

# while 循环三要素
# 1.设定一个初始值
# 2.对初始值进行条件判断，增加一个条件语句，对初始值进行一个条件表达式的限制
# 3.初始值的自增长

i = 0
while i < 5:
    print("yangyu")  # 打印5次yangyu
    i += 1

示例3

i = 0
while i < 5:
    print(i)  # 打印0 1 2 3 4
    i += 1
    print(i)  # 打印1 2 3 4 5

示例4

# 完整的while循环语句的语法：当while循环正常执行结束，else语句就会执行，否则就不会执行
# while 条件表达式 :
#     代码块
# else：
#     代码块
i = 0
while i < 5:
    print(i)  # 打印0 1 2 3 4
    i += 1
    print(i)  # 打印1 2 3 4 5
else:
    print("程序正常执行结束")

示例5

# 求100以内的所有偶数之和
# 1. 首先获得1-100的数
# 2. 筛选出偶数
# 3. 偶数相加
i = 0
res = 0
while i < 100:
    i += 1
    # print(i)
    if i % 2 == 0:
        res += i  # res = res + i
print(res)  # 2550

# 方法二 直接取偶数相加
i = 0
res = 0
while i < 100:
    i += 2
    res += i
print(res)  # 2550

2.break和continue

• break 可以用来立即退出循环语句,包括else语句
• continue 用来跳过当次循环

示例1

# break 可以用来立即退出循环语句,包括else语句
# continue 用来跳过当次循环

i = 0
while i < 5:
    i += 1
    if i == 4:
        continue  # 跳过，该代码块都不执行
        print("yangyu is a god")
    print(i)
else:
    print("yangyu")
'''
1
2
3
5
yangyu
'''

i = 0
while i < 5:
    i += 1
    if i == 4:
        break  # 立即退出循环语句,后面包括else语句统统不执行
        print("yangyu is a god")
    print(i)
else:
    print("yangyu")
'''
1
2
3
'''

示例2

# 外面再套1个while循环
j = 0
while j < 2:
    i = 0
    while i < 5:
        i += 1
        if i == 4:
            break  # 只能终止所在的while循环
            print("yangyu is a god")
        print(i)
    else:
        print("yangyu")
    j += 1
    
'''
1
2
3
1
2
3
'''

3.for循环遍历

for循环

• 通过for循环来遍历列表
  语法:
  for 变量 in 序列(遍历的规则):
      代码块
• 注意: for循环的代码块会执行多次,序列中有几个元素就会执行几次。每执行一次就会将序列中的一个元素赋值给变量,所以我们可以通过变量来获取列表中的元素

示例

# for循环——————————————简洁
list1 = [1, 2, 3, 4, 5, 6, 7]
print(list1[0])  # 1
print(list1[1])  # 2
print(list1[2])  # 3
print(list1[3])  # 4
print(list1[4])  # 5
print(list1[5])  # 6
print(list1[6])  # 7

i = 0
while i < len(list1):
    print(list1[i])
    i += 1
'''
1
2
3
4
5
6
7
'''
# for循环遍历容器内的数据
# 语法
# for 变量 in 序列(遍历的规则)：
#     代码块  
for i in list1:
    print(i)
    # break
else:
    print("循环正常结束")
'''
1
2
3
4
5
6
7
循环正常结束
'''
for i in list1:
    print(i)
    i += 1   # 在内部做算术操作不影响列表遍历元素，也不影响列表本身
else:
    print("循环正常结束")
print(list1)
'''
1
2
3
4
5
6
7
循环正常结束
[1, 2, 3, 4, 5, 6, 7]
'''
for i in list1:
    print(i)
    list1.remove(i)   # 在内部做删除操作，等于遍历地删除列表中的元素，直接改变列表本身，所以不建议在遍历列表中做操作
else:
    print("循环正常结束")
print(list1)
'''
1
3
5
7
循环正常结束
[2, 4, 6]
'''

4.range(start, stop[, step])

参数说明

• start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
• stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
• step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

示例

# range(开始数据，结束数据，步长)  左闭右开区间  可以省略开始数据和步长。开始数据默认0，步长默认1
range(5)   # 相当于range(0,9,1) 格式相当于[0, 1, 2, 3, 4]
for i in range(5):
    print(i)
'''
0
1
2
3
4
'''
print(range(5))  # range(0, 5)
print(list(range(5)))  # [0, 1, 2, 3, 4]

三.循环嵌套

循环嵌套

Python 语言允许在一个循环体里面嵌入另一个循环。

while 表达式:
    while 表达式:
        代码块
    代码块

for 变量 in 循环规则:
    for 变量 in 循环规则:
        代码块
    代码块

示例1

# while 循环嵌套
i = 0
while i < 5:
    j = 0
    while j < 5:
        print("*", end='')  # 打印一行5个*
        j += 1
    print()  # 换行
    i += 1  # 打印5行
'''
*****
*****
*****
*****
'''

示例2

*     i 行打印i+1个*       0打印1个
**                         1打印2个      j < i+1
***
****
*****
'''
i = 0
while i < 5:
    j = 0
    while j < i + 1:
        print("*", end='')  # 打印i+1个*
        j += 1
    print()  # 换行
    i += 1  # 打印5行

示例3

'''
*****     i = 0   j < 5       打印5个
****      i = 1   j < 5 - i   打印4个
***       i = 2   j < 5 - i   打印3个
**        i = 3   j < 5 - i   打印2个
*         i = 4   j < 5 - i   打印1个
'''

i = 0
while i < 5:
    j = 0
    while j < 5 - i:
        print("*", end='')  # 打印5 - i个*
        j += 1
    print()  # 换行
    i += 1  # 打印5行

示例4

# 9*9乘法表  方法1：
i = 0
while i < 9:  # 控制列
    i += 1
    j = 0
    while j < i:  # 控制行
        j += 1
        print(f'{j}*{i}={j*i}', end="\t")  # 用制表符分隔
    print()  # 换行
'''
1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81	
'''
# 9*9乘法表  方法2：
for i in range(1, 10):
    for j in range(1, i+1):
        print('{}x{}={}\t'.format(j, i, i*j), end='')
    print()
'''
1x1=1	
1x2=2	2x2=4	
1x3=3	2x3=6	3x3=9	
1x4=4	2x4=8	3x4=12	4x4=16	
1x5=5	2x5=10	3x5=15	4x5=20	5x5=25	
1x6=6	2x6=12	3x6=18	4x6=24	5x6=30	6x6=36	
1x7=7	2x7=14	3x7=21	4x7=28	5x7=35	6x7=42	7x7=49	
1x8=8	2x8=16	3x8=24	4x8=32	5x8=40	6x8=48	7x8=56	8x8=64	
1x9=9	2x9=18	3x9=27	4x9=36	5x9=45	6x9=54	7x9=63	8x9=72	9x9=81'''
for i in range(1, 10):
    print()
    for j in range(1, i + 1):
        print("%d*%d=%d" % (j, i, i * j), end="\t")
'''

1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81	'''

第五讲作业

1. 写博客

2. 练习课堂中老师敲的代码

3. 求1000以内所有的水仙花数

'''
3. 求1000以内所有的水仙花数
#一个N位数，其各个数位上的数的n次方之和恰好等于原数，这样的数叫做“自幂数”。Narcissus number，又称“纳西塞斯”数
#水仙是指一个 3位数 ( n=3 )，它的每个位上的数字的3次幂之和等于它本身。（例如：1^3 + 5^3 + 3^3 = 153）
'''
# 方法一  分别对百位数、十位数、个位数进行取值，在if语句打印百位数的三次幂 + 十位数三次幂 + 个位数三次幂 == i的值
i = 100
while i < 1000:
    a = i // 100
    b = (i // 10) % 10
    c = i % 10
    if a ** 3 + b ** 3 + c ** 3 == i:
        print(i)
    i += 1
'''
153
370
371
407
'''
# 方法二  将所求的数字转换成str，对str切片，再将切片转为int类型，在if语句打印百位数的三次幂 + 十位数三次幂 + 个位数三次幂 == i的值
i = 100
while i < 1000:
    a = str(i)
    if int(a[0]) ** 3 + int(a[1]) ** 3 + int(a[2]) ** 3 == i:
        print(i)
    i += 1
'''
153
370
371
407
'''

4. 获取用户输入的任意数，判断其是否是质数?

# 4. 获取用户输入的任意数，判断其是否是质数?
'''
质数又称素数。一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数。最小的质数是2，
它也是唯一的偶数质数。最前面的质数依次排列为：2，3，5，7，11等。
'''
# 用户输入数字
num = int(input("请输入一个数字: "))

# 质数大于 1
if num > 1:
    # 查看因子
    for i in range(2, num):
        if (num % i) == 0:
            print(num, "不是质数")
            print(i, "乘于", num // i, "是", num)
            break
    else:
        print(num, "是质数")

# 如果输入的数字小于或等于 1，不是质数
else:
    print(num, "不是质数")

5. 猜拳游戏：

• 出拳 玩家：手动输入 电脑：随机输入
• 判断输赢： 玩家获胜 电脑获胜 平局

import random
# 1表示剪刀，2表示石头，3表示布
sys_list = [1, 2, 3]
while True:
    player_int = int(input("请输入数字(1表示剪刀,2表示石头,3表示布,0表示退出)："))  # 玩家出招
    if player_int == 0:
        break
    while player_int in sys_list:   # 玩家输入正确的数字进入游戏
        computer = random.choice(sys_list)  # 电脑出招
        print("你出的是%s,电脑出的是%s" % (player_int, computer))
        if computer == player_int:
            print("平局")
            break
        elif computer == 2 and player_int == 1:
            print("你输了")
            break
        elif computer == 3 and player_int == 2:
            print("你输了")
            break
        elif computer == 1 and player_int == 3:
            print("你输了")
            break
        else:
            print("你赢了")
            break
    else:
        print("你输入的数字是%s输入错误，只能输入1,2,3当中的一个数字，请重输" % player_int)

第六讲作业

1. 现在有 a = [1,2,3,4,5,6] 用多种方式实现列表的反转([6,5,4,3,2,1]) 并写出推导过程

# 1. 现在有 a = [1,2,3,4,5,6] 用多种方式实现列表的反转([6,5,4,3,2,1]) 并写出推导过程
a = [1, 2, 3, 4, 5, 6]
# 第一种  切片 省略开头0和结尾,就默认取全部,步进是-1,由右向左排序
b = a[::-1]
print(b)  # [6, 5, 4, 3, 2, 1]
# 第二种 使用reverse() 方法对列表中的元素进行反向排序
a.reverse()
print(a)
# 第三种 使用sort()方法,参数reverse=True表示按降序排列,False表示按升序进行排序,False是默认值。
a.sort(reverse=True)
print(a)  # [6, 5, 4, 3, 2, 1]
# 第4种方法 使用for循环
a = [1, 2, 3, 4, 5, 6]
b = []
for i in a:
    b.insert(0, i)
print(b)

2. 给 用户9次机会 猜1 - 10 个数字随机来猜数字。如果随机的数字和用户输入的数字一致则表示正确，如果不一致则表示错误。最终结果要求用户怎么也猜不对

'''
2.给用户9次机会 猜1 - 10 个数字随机来猜数字。
如果随机的数字和用户输入的数字一致则表示正确，如果不一致则表示错误。
最终结果要求用户怎么也猜不对
'''
import random

i = 1
while i < 10:
    int_num = int(input("请输入1-10之间数字："))
    while int_num in range(1, 11):
        list1 = list(range(1, 11))  # 产生包含1-10的列表
        list1.remove(int_num)  # 删除玩家输入的数字
        random_num = random.choice(list1)  # 产生玩家输入的数字之外1-10之间的随机数
        print("第%d次：猜错了!您输入的数字是%s,电脑输入的数字是%s,请重新输入！" % (i, int_num, random_num))
        break
    else:
        print("第%d次：您输入的数字是%s,不符合要求！" % (i, int_num))
    i += 1

3. 有两个列表 lst1 = [11, 22, 33] lst2 = [22, 33, 44]获取内容相同的元素

# 3. 有两个列表 lst1 = [11, 22, 33] lst2 = [22, 33, 44]获取内容相同的元素
# 方法一：两个列表相加得到的用切片方法得到每一个元素放进while循环中统计出现次数>=2的元素
lst1 = [11, 22, 33]
lst2 = [22, 33, 44]
lst1.extend(lst2)
i = 0
lst3 = []
while i < len(lst1):
    if lst1.count(lst1[i]) >= 2:
        if lst1[i] not in lst3:
            lst3.append(lst1[i])
        else:
            pass
    i += 1
print(lst3)
# [22, 33]

# 方法二：在while循环中取lst1列表的每一个元素去判断是否在lst2列表中，存在就存进lst3中
lst1 = [11, 22, 33]
lst2 = [22, 33, 44]
i = 0  # 索引初始值 = 0
lst3 = []
while i < len(lst1):
    if lst1[i] in lst2:
        lst3.append(lst1[i])
    else:
        pass
    i += 1
print(lst3)
# [22, 33]

# 方法三：用嵌套for循环遍历每一个元素，进行对比，如果相等添加到新的列表3中。
lst1 = [11, 22, 33]
lst2 = [22, 33, 44]
lst3 = []
for i in lst1:
    for j in lst2:
        if i == j:
            lst3.append(i)
        else:
            pass
print(lst3)
# [22, 33]

# 方法四：使用set()将列表转换为集合，然后取并集，再转换为列表
lst1 = [11, 22, 33]
lst2 = [22, 33, 44]
print(list(set(lst1) & set(lst2)))
'''
[33, 22]
'''

4. 现在有8位老师，3个办公室，要求将8位老师随机的分配到三个办公室中

# 4. 现在有8位老师，3个办公室，要求将8位老师随机的分配到三个办公室中
import random

# 把老师放到一个数组中
teachers = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
# 定义一个新的二维数组
offices = [[], [], []]
# 使用for循环进行数组teachers的遍历
for name in teachers:
    # 随机分配的办公室进行赋值
    offices[random.randint(0, 2)].append(name)
# 打印输出offices数组
print(offices)
# [['c', 'd', 'e'], ['a', 'g', 'h'], ['b', 'f']]

5. 现在有8位老师，3个办公室，要求将8位老师随机的分配到三个办公室中，要求，每个办公室至少有一位老师。

# 5. 现在有8位老师，3个办公室，要求将8位老师随机的分配到三个办公室中，要求，每个办公室至少有一位老师。
# 方法1
import random

# 把老师放到一个数组中
teachers = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
# 定义一个新的二维数组
offices = [[], [], []]
# 随机选择一位老师分配到办公室,并在原来列表中将老师删除
first_teacher = random.choice(teachers)
office1 = offices[0].append(first_teacher)
teachers.remove(first_teacher)
# 随机选择一位老师分配到办公室,并在原来列表中将老师删除
second_teacher = random.choice(teachers)
office2 = offices[1].append(second_teacher)
teachers.remove(second_teacher)
# 随机选择一位老师分配到办公室,并在原来列表中将老师删除
third_teacher = random.choice(teachers)
office3 = offices[2].append(third_teacher)
teachers.remove(third_teacher)
# 使用for循环进行数组teachers的遍历
for name in teachers:
    # 随机分配的办公室进行赋值
    offices[random.randint(0, 2)].append(name)
# 打印输出offices数组
print(offices)
# [['c', 'd', 'e'], ['a', 'g', 'h'], ['b', 'f']]

# 方法2
import random

while True:
    # 把老师放到一个数组中
    teachers = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
    # 定义一个新的二维数组
    offices = [[], [], []]
    for name in teachers:
        # 随机分配的办公室进行赋值
        offices[random.randint(0, 2)].append(name)
    if len(offices[0]) == 0 or len(offices[1]) == 0 or len(offices[2]) == 0:
        continue
    else:
        # 打印输出offices数组
        print(offices)
        break
# [['b', 'g', 'h'], ['a', 'c', 'd', 'e'], ['f']]