Python学习--更新7.28

已于 2024-07-28 19:57:44 修改
阅读量277 收藏 4
点赞数 4
文章标签： python 学习
于 2024-07-06 11:09:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51167292/article/details/140224464
版权

Python学习–更新中

基本概念

Python：是一种面向对象的解释型计算机程序设计语言
C：是一种面向过程的编译型计算机程序设计语言

标识符

标识符严格区分大小写

  • 数字不能开头

  • 只能用 字母、数字、下划线

标识符的命名规范：

  1. 模块名尽量短小，并且全部使用小写字母，可以使用下划线分隔多个字母 eg： grame_main
  2. 包名尽量短小，并且全部使用小写字母，不推荐使用下划线 eg： com.ysjpython
  3. 类名采用单词首字母大写形式（大驼峰命名规则）。 eg： MyClass
  4. 模块内部的类采用"_" + 大驼峰风格。 eg： _InnerMyClass
  5. 函数、类的属性和方法的命名，全部使用小写字母，多个字母之间用下划线分隔
  6. 常量命名时采用全部大写字母，可以使用下划线
  7. 使用单下划线"_“开头的模块变量或函数是受保护的，在使用"from xxx import *” 语句从模块中导入时，这些模块变量或函数不能被导入
  8. 使用双下划线"_"开头的实例变量或方法是类私有的
  9. 以双下划线和结尾是Python的专用标识，例如： init()表示初始化函数
函数的命名规范

命名一个星光开火车的函数：

  • 小驼峰命名规则：starlightDriveTrain
  • 大驼峰命名规则：StarlightDriveTrain
  • 下划线命名规则：starlight_drive_train

关键字

关键字严格区分大小写
有些单词被 python 语法赋予了特殊含义，这些单词我们在编程中是不可以直接使用的。关键字是偏程语言里事先定义好并赋予了特殊含义的单词，也称为保留字.
关键字有35个：

[‘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’]

# 导入系统的 keyword 库/模块
import keyword

# 输出查看系统的关键字列表
print(keyword.kwlist)

# 输出查看系统的关键字列表的总长
print(len(keyword.kwlist))

'''

数据类型

基本数据类型

整型int

表示的数值是没有小数部分的数值，包含正整数、负数和0

num1 = 999                  # 默认十进制
num2 = 0b101001        # 二进制，由字符0和1组成
num3 = 0o755              # 八进制，由字符0~7组成
num4 = 0x87ABF          # 十六进制，由字符0~9，a~f或A~F组成
print(num1, num2, num3, num4)

浮点型float

表示带有小数点的数值，有整数部分和小数部分组成
两个浮点数类型的数在运算时，有一定的概率运算结果后增加一些不确定的尾数
round 函数

round(number, digits)
用于对数值进行四舍五入操作

# 不确定尾数问题
print(0.1 + 0.2)
print(round(0.1 + 0.2, 1))      # 保留一位小数

布尔类型bool

只有两个结果：True/False
True表示整数1，False表示整数0

布尔值为False的情况：
数值中的0，0.0，虚数0
孔旭烈，包含空字符串、空元组、空列表、空字典、空集合
自定义对象的实例，该对象的_bool_()方法返回False或_len_()方法返回0

print(True + 10)		# 11
print(False + 10)		# 10

print(bool(0), bool(0.0))
print(bool('我爱你'))
print(bool(''))
print(bool(None))
print(bool(False))

数据类型的转换

类型转换分为隐式转换 和 显式转换

int(x) 将x转换为整数类型
float(x) 将x转换为浮点数类型
str(x) 将x转为字符串
chr(x) 将整数x转换为一个字符
ord(x) 将字符s转换为其对应的整数值
hex(x) 将一个整数x转换为一个十六进制的字符串
oct(x) 将一个整数x转换为一个八进制的字符串
bin(x) 将一个整数x转换为一个二进制的字符串

x = 3
y = 10
z = x / y       # 隐式转换
print(f'z = {z}, type(z) = {type(z)}')

print(f'str(z) = {str(z)}, type(str(z)) = {type(str(z))}')

# chr(x)   将整数x转换为一个字符
# ord(x)    将一个字符转换为其对应的整数值
print(ord('赵'))
print(chr(36213))

# 进制之间的转换操作
print('十进制 -> 十六进制', hex(36213))
print('十进制 -> 八进制', oct(36213))
print('十进制 -> 二进制', bin(36213))

string -> int

num1 = '10'
num2 = '20'
result = num1 + num2        #字符串相拼接
print(f'type(num1) = {type(num1)}, type(num2) = {type(num2)}')
print(f'result = {result}')

n1 = int(num1)
n2 = int(num2)
result = n1 + n2
print(f'type(n1) = {type(n1)}, type(n2) = {type(n2)}')
print(f'result = {result}')

int -> float

n1 = 10
n2 = 20

f1 = float(n1)
f2 = float(n2)
result = f1 + f2
print(f'result = {result}')

float -> int

f1 = 66.66
f2 = 88.88
result = f1 + f2
print(f'result = {result}')

i1 = int(f1)
i2 = int(f2)
result = i1 + i2
print(f'result = {result}')

int + float = float

n = 10
f = 5.5555
result = n + f
print(f'result = {result}')

基本数据类型 VS 对象数据类型

  • 基本数据类型： 不需要考虑地址问题
  • 对象数据类型： 需要考虑内存地址问题

字符串类型string

字符串又被称为有序的字符序列，对字符串中某个字符的检索称为索引。
字符串类型是对象数据类型。

字符串的相关操作
字符串的基本操作
x + y  ：将x与y连接起来
x*n 或 n*x ：复制n次字符串x
x in s ：判断x是否为s的子串，是True，否False

x = '深海'
y = '爱章鱼'
print(x + y)              # 连接两个字符串
print((x + y)*10)       # 复制十次

print('祖国人' in (x + y))
print('深海' in (x + y))
字符串的切片操作

对字符串某个子串或区间的检索，就是将原来的字符串实现切割
切片是有下标的，因为字符串是一个序列。列表、集合都是有下标的

字符串切片操作的语法结构：
字符串[start:stop:step]

  1. start 开始(默认从头开始，位置为0)
  2. stop 结束(默认到结尾)
  3. step 步长(默认为1)
str = 'hello,python'

# str[6]   =>  p
# 这个不是切片，通过索引获取字符串中对应的索引字符.      index = 6
print(f'str[6] = {str[6]}')

# str[6:12] => python
# 是切片,从6开始切，切到12这个位置(不包含12)
print(f'str[6:12] = {str[6:12]}')

# 需求：将hello字符串切割出来
print(f'str[0:5] = {str[0:5]}')

# str[1:10:2] 会得到什么
print(f'str[1:10:2] = {str[1:10:2]}')
string 类的驻留机制

相同的字符串在程序运行期间，其内存中仅存储一份

# id(对象名)  查看‘对象’在内存的地址
s1 = 'python'
s2 = 'python'
s3 = 'python'

print(f's1 = {s1},id(s1) = {id(s1)}')
print(f's2 = {s2},id(s2) = {id(s2)}')
print(f's3 = {s3},id(s3) = {id(s3)}')

# 字符串内容发生变化，改变的是该字符串的引用地址，而不是该字符串地址对应的内存数据
s1 = 'hello'

print(f's1 = {s1},id(s1) = {id(s1)}')
print(f's2 = {s2},id(s2) = {id(s2)}')
print(f's3 = {s3},id(s3) = {id(s3)}')
转义字符
\t	水平制表符
\n	换行符
\\	字符反斜杠
\'	字符单引号

print('She says : 'i love you'')	#错误
print('She says : \'i love you\'')

原字符：使转义字符失效的符号，r 或 R

print('北\n京\n欢\n迎\n你')
print(r'北\n京\n欢\n迎\n你')

组合数据类型

序列和索引

序列是一个用于存储多个值的连续空间，每个值都对应一个整数的编号，称为索引

有序序列：列表和元组
无序序列：集合和字典

索引是序列当中元素的编号

正向递增索引
反向递减索引

在这里插入图片描述

使用索引检测字符串中元素
# 正向递增
s = 'helloworld'            # 字符串的长度 == 10
for i in range(0, len(s)):          # 从0开始，到字符串的长度10（不包括10），即0~9
    print(i, s[i], end='\t\t')
print('\n------------------------------------------------------')

# 逆向递减
s = 'helloworld'
for i in range(-10, 0):             # -10~-1
    print(i, s[i], end='\t\t')
print('\n------------------------------------------------------')
序列的相关操作
切片操作

切片操作，不仅用于字符串中，而且可以用于所有的序列类型

切片操作的语法结构：
序列[start: stop: step]

  1. start 开始(默认从头开始，位置为0)
  2. stop 结束(默认到结尾)
  3. step 步长(默认为1)
s = 'helloworld'

s1 = s[0:5:2]		# 从0开始切到5（不包含5），步长为2
print(s1)
s2 = s[::]				# 从0开始到结尾（默认包含最后一个元素），步长为1
print(s2)

# 省略stop位，默认到序列的最后一个元素(包含最后一个元素)
s3 = s[0::1]			# 从0开始到结尾（默认包含最后一个元素），步长为1
print(s3)

# 省略start、stop位
s4 = s[::2]			# 从0开始到结尾（默认包含最后一个元素），步长为2
print(s4)

# 步长为负数
s5 = s[::-1]			# 从0开始到结尾（默认包含最后一个元素），步长为-1
print(s5)
序列的相加
s1 = 'hello'
s2 = 'world'
print(s1 + s2)
序列的相乘
print(s1*5)
print('-'*10)
序列的相关操作符和函数的使用
操作符/函数描述说明
x in s如果x是s的元素，结果为True，否则为False
x not in s如果x不是s的元素，结果为True，否则为False
len(s)序列s中元素的个数（序列的长度）
max(s)序列s中元素的最大值
min(s)序列s中元素的最小值
s.index(x)序列s中第一次出现元素x的位置
s.count(x)序列s中出现x的总次数
s = 'helloworld'

print('e在helloworld中存在吗？', ('e' in s))  # in 的使用
print('v在helloworld中存在吗？', ('v' in s))

print('e在helloworld中不存在吗？', ('e' not in s))     # not in 的使用
print('v在helloworld中不存在吗？', ('v' not in s))

# 内置函数的使用
print(f'len(s)={len(s)}')			# 求序列的长度
print(f'max(s)={max(s)}')      # 求最大值，按照ASCII码
print(f'min(s)={min(s)}')        # 求最小值

# 序列对象的方法：使用序列的名称，打点调用
print(f's.index(o)={s.index("o")}')         # o在s中第一次出现的索引位置
print(f's.index(v)={s.index("v")}')         # ValueError: substring not found，v在字符串中根本不存在
print(f's.count(o)={s.count("o")})')        # 统计o在字符串s中出现的次数

元组类型

特点：有序、可重复、不可扩展

names = ('祖国人','星光','火车人','祖国人')
print(f'names={names},type(names)={type(names)}')
列表类型

列表是指一系列的按照特定序列排列的元素组成
是python中内置的可变序列
在python中使用[ ]定义列表，元素与元素之间使用英文的逗号分隔
列表中的元素可以是任意的数据类型
特点：有序、可重复、可扩展

names = ['祖国人','星光','火车人','祖国人']
print(f'names={names},type(names)={type(names)}')
列表的相关操作
列表的基本操作

列表的创建

  1. 使用[ ]直接创建列表

语法结构：
列表名 = [element1, element2, …, elementN]

  1. 使用内置函数list()创建列表

语法结构：
列表名 = list(序列)

# 直接使用[ ]创建列表
list1 = ['hello', 'world', 98, 100.5]
print(list1)

# 使用list创建列表
list2 = list('hello world')
list3 = list(range(1, 10, 2))
print(list2)
print(list3)

# 列表是序列的一种，对序列的操作符，运算符，函数均可以使用
print(list1 + list2 + list3)
print(list1 * 3)        # 列表相乘
print(f'len(list1) = {len(list1)}')
print(f'max(list3) = {max(list3)}')
print(f'min(list3) = {min(list3)}')

print(f'list2.count(o)={list2.count("o")}')         # 统计list2中o的出现次数
print(f'list2.index(o)={list2.index("o")}')          # 查找list2中o第一次出现的位置

列表的删除

语法结构：
del 列表名

# 列表的删除操作
list4 = [1, 2, 3]
print(list4)

del list4
# print(list4)            # NameError: name 'list4' is not defined. Did you mean: 'list1'?
列表的特有操作
列表的方法描述说明
lst.append(x)在列表lst最后增加一个元素
lst.insert(index, x)在列表lst中地index位置增加一个元素
lst.clear()清除列表lst中所有元素
lst.pop(index)将列表lst中第index位置的元素去除，并从列表中将其删除
lst.remove(x)将列表lst出现的第一个x删除
lst.reserve()将列表lst中的元素反转
lst.copy()拷贝列表lst中的所有元素，生成一个新的列表
list1 = ['hello', 'world', 'python']
print('原列表：', list1, id(list1))          # id()函数 返回对象的内存地址

# 增加元素操作
list1.append('sql')
print('增加元素之后：', list1, id(list1))       # 元素个数发生改变，但是内存地址不变

# 使用insert(index, x)在指定的index位置上插入元素x
list1.insert(1, 100)
print('插入元素之后', list1, id(list1))

# 删除元素操作
list1.remove('world')
print('删除元素之后', list1, id(list1))

# 使用pop(index)根据索引将元素取出，然后再删除
print('将索引为1的元素取出', list1.pop(1))
print('将索引为1的元素取出之后', list1, id(list1))

# 列表的反向
list1.reverse()
print('将列表中的元素反转', list1, id(list1))

# 列表的拷贝，将产生一个新的列表对象
new_list1 = list1.copy()
print('原列表', list1, id(list1))
print('拷贝产生的新列表', new_list1, id(new_list1))

# 列表元素的修改，根据索引进行修改元素
list1[1] = 'mysql'
print(list1, id(list1))

# 清除列表所有元素clear()
list1.clear()
print('清除列表元素之后', list1, id(list1))

列表的排序

  1. 列表对象的sort方法
  2. 内置函数sorted()
集合类型

特点：无序、不可重复、可扩展

names = {'祖国人','星光','火车人','祖国人'}
print(f'names={names},type(names)={type(names)}')
字典类型

key - > value

stu_dict = {'stu_id' : '1001' , 'name' : '祖国人' , 'age' : '15' , 'score' : 100}
print(f'stu_dict={stu_dict},type(stu_dict)={type(stu_dict)}')

print输出函数

print输出函数默认换行

print('I am homelander')		# end = '\n'
print('I am homelander',end = '')		# end = ''空字符串

input输入函数

  • input() 定义一个变量去接受 input 函数返回的结果
  • input函数是一个阻塞函数
  • input 返回的结果是 str 类型
num1 = int(input("Enter a number: "))
num2 = int(input("Enter another number: "))
sum = num1 + num2
print(f'The sum of {num1} and {num2} is {sum}')

eval函数

用于去掉字符串最外侧的引号，并按照python语句方式执行去掉引号后的字符串
eval()经常与input()函数一起使用

eval()语法格式：
变量 = eval(字符串)

s = '36213 + 9'
print(f'eval(s) = {eval(s)}')   # 去掉引号 执行 36213 + 9

# eval() 经常与 input() 一起使用
age = eval(input('请输入您的年龄：'))
height = eval(input('请输入您的身高：'))

print(f'type(age) = {type(age)}')
print(f'type(height) = {type(height)}')

# x = '祖国人大战风暴女'
# print(eval(x))          # NameError: name '祖国人大战风暴女' is not defined

运算符

算术运算符
运算符描述说明示例结果
+加法1 + 12
-减法1 - 10
*乘法2 * 36
/除法10 / 25
//整除10 / 33
%取余10 % 31
**幂运算2 ** 38

算术优先级由高到低：

第一级：**
第二级：*、/、%、//
第三级：+、-

r1 = 10/3
print(f'r1 = {r1}')

r2 = 10//3
print(f'r2 = {r2}')

r3 = 10%3
print(f'r3 = {r3}')

r4 = 2 **3
print(f'r4 = {r4}')
复合赋值运算
运算符描述说明示例展开形式
=赋值运算x = yx = y
+=加赋值x += yx = x + y
-=减赋值x -= yx = x - y
*=乘赋值x *= yx = x * y
/=除赋值x /= yx = x / y
%=取余赋值x %= yx = x % y
**=幂赋值x **= yx = x ** y
//=整除赋值x //= yx = x // y
num1 = 10
num1 += 1   #num1 = num1 + 1
print(f'num1 = {num1}')
逗号表达式

原理：元组解包

num1,num2,num3=10,20,30

# ValueError: too many values to unpack (expected 3)   太多值参与解包
# num1,num2,num3=10,20,30,40,50

print(f'num1 = {num1}, num2 = {num2}, num3 = {num3}')

# python支持链式赋值
a = b = c = d = e = 1
print(a, b, c, d, e)

# python支持系列解包赋值
a, b = 10, 20
print(a, b)

# 交换两个变量的值
a, b = b, a
print(a, b)
比较运算符

比较运算符： > ，< ， >= ， <= ， != ， ==
运算符前后都有一个空格
其结果是 bool类型 -> True / False

num1 = 10
num2 = 20

result = num1 > num2
print(f'result = {result}')
逻辑运算符
运算符描述说明用法结合方向
and逻辑与表达式1 and 表达式2从左到右
or逻辑或表达式1 or 表达式2从左到右
not逻辑非not 表达式从右到左
# and
print('*' * 66)
print(7 < 8 and 9 > 6)
print(1 > 2 and 3 > 4)
print(2 > 1 and 3 > 4)
print(1 > 3 and 10 / 0)     # 左侧表达式为False，右侧表达式不执行

# or
print('*' * 66)
print(7 < 8 or 9 > 6)
print(1 > 2 or 3 > 4)
print(2 > 1 or 3 > 4)
print(8 > 7 or 10 / 0)      # 左侧表达式为True，右侧表达式不执行

# not
print('*' * 66)
print(not True)
位运算符

把数字看作二进制来进行计算

运算符符号运算规则
按位与&两位同时为1，结果才为1，否则结果为0
按位或I两位同时为0时，结果才为0，否则结果为1
按位取反~0变1，1变0
按位异或^两位相同为0，相异为1
左移<<各二进位全部左移若干位，高位丢弃，低位补0
右移>>各二进位全部右移若干位，对无符号数，高位补0；有符号数，最高位是1(负数)，高位补1，最高位是0，高位补0
# 按位与
print(f'12 & 8 = {12 & 8}')     # 1100 & 1000  == 1000

# 按位或
print(f'12 | 8 = {12 | 8}')         # 1100 | 1000 == 1100

# 按位取反
print(f'~12 = {~12}')               # ~(0)1100 == (1)0011       补码，符号位为1

# 按位异或
print(f'12 ^ 8 = {12 ^ 8}')         # 1100 ^ 1000 == 0100

# 左移
print(f'2 << 2 = {2 << 2}')         # 0010 << 2 == 1000

# 右移
print(f'2 >> 3 = {2 >> 3}')         # 0010 >> 3 == 0000
print(f'-2 >> 3 = {-2 >> 3}')       # (1)1110 >> 3 == (1)1111           -2 原码为(1)0010  补码为 (1)1110
三目运算符

其实就是if…else…双分支结构的缩写形式.
缺陷：具有局限性，分支结构简单

结果1 if 条件表达式 else 结果2

结果1：条件成立时返回的结果。
结果2：条件不成立时返回的结果。

# 从三个整型数值中找到最大值
num1 = int(input('Enter first number: '))
num2 = int(input('Enter second number: '))
num3 = int(input('Enter third number: '))

second_max = num1 if num1 > num2 else num2
first_max = num3 if num3 > second_max else second_max

print(f'max = {first_max}')

程序的组织结构

顺序结构

按照程序语句的自然顺序，从上到下，依次执行每条语句的程序

赋值语句
输入/输出语句
模块导入语句

# 赋值运算符的顺序  从右到左
name = '张三'
age = 20
a = b = c = d = 100     # 链式赋值
print(a, b, c, d)
a, b, c, d = 'room'     # 字符串分解赋值
print(a, b, c, d)

选择结构

也称分支结构，按照条件选择执行不同的代码段

if语句

  • 单分支

if 条件表达式:
执行语句1
执行语句2
执行语句3
…

#定义变量接收出生年份，判断这个哥们是否成年
if (2024 - year) >= 18:
    print('恭喜')

print('程序继续进行...')
  • 双分支

if 条件表达式：
执行语句1
else:
执行语句2

#如果你儿子成绩及格了，就奖励他否则，打死他。
score = int(input('请输入儿子的成绩：'))
if score >= 60:
    print('奖励')
else:
    print('打死')

print('程序继续进行...')
  • 多分支

if 条件表达式1:
执行体1
elif 条件表达式2:
执行体2
elif 条件表达式N:
执行体3
else:
执行体4

#对一个学生的考试成绩进行等级的划分，如果分数大于等于80分等级为优,否则，如果分数大于等于70等级为良，
# 否则，如果分数大于等于60分等级为中，否则，等级为差.
score = int(input('请输入您的成绩：'))
if 80 <= score <= 100:
    print('优')
elif 70 <= score < 80:
    print('良')
elif 60 <= score < 70:
    print('中')
elif 0 <= score < 60:
    print('差')
else:
    print('成绩非法')
  • if 嵌套语句
    if 嵌套
answer = input("请问你是会员吗: (y会员  n非会员)")
money = int(input("请问你消费了多少钱: "))
if answer == 'y' or answer == 'Y':           # 会员代码组
    if money >= 200:
        print("打8折")
    elif money >= 100:
        print("打9折")
    else:
        print("不打折")
else:                                                        # 非会员代码组
    if money >= 200:
        print("打9.5折")
    else:
        print("不打折")

循环结构

while 语句

# 1. 定义循环变量
i = 0

# 2. 设置循环条件
while i < 10:
    print('我要循环10次', i)

    # 3. 循环增量
    i += 1

练习：

# 找出 1~100 之间的偶数
i = 1
print('1~100 之间的偶数为')
while i <= 100:
    if i % 2 == 0:
        print(i, end='\t')
    i += 1

for 语句

for 循环变量 in range(start, stop, step)

range(start, stop, step)

python 内置函数
作用：生成指定范围的序列。

  1. start 开始的数值(默认为0)
  2. stop 结束的数值(不包含该数值) 必须指定
  3. step 步长(默认为1)
# 练习：使用 for 循环，求 1~100 之间所有整数的累加和
i_sum = 0
for i in range(1, 101):				# start 从1开始  stop 为101 循环次数为100
    i_sum += i
    print(i_sum, end='\t')
for 循环与 while 循环的区别

while 一般用于不知道循环次数的情况下；

while True:			break

for 一般用于已知循环次数的情况下；

for + range
for 循环的嵌套

嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的诰法结构． 类似于大圈套小圈． 嵌套循环的特点 ：
外层循环每执行一次，内层循环就要执行所有次，外面的事情如果要完成一次，里面的事情要完成所有次.

# 九九乘法表
for i in range(1, 10):              # [1, 2, 3, 4, 5, 6, 7, 8, 9]
    for j in range(1, i + 1):      # [1, 2, 3, 4, 5, 6, 7, 8, 9]
        print(f'{i}* {j} = {i * j}', end='\t')
    print()

break 语句

结束当前循环

# 需求：询问你的女朋友到底爱不爱你？
# 如果她的回答是不爱，那就往死里问，直到你女朋友说爱你为止，然后你说，那我们就结婚吧，最后跳出循环
while True:
    answer = input('你到底爱不爱我？(y or n)')
    if answer == 'y' or answer == 'Y':
        print('我们结婚吧！！')
        break

continue 语句

终止本次循环，进入下一次循环

for i in range(10):
    if i == 5:
        continue            # 当 i == 5 时，循环后面的代码不执行，回到循环条件处，执行下一趟
    print(i)

pass语句

pass是python中的保留字，在语法结构中只起到占位符的作用，使语法结构完整，不报错
一般用于if、for、while、函数的定义、类的定义中

break 语句与 continue 语句的区别

  • break 往循环外面跳
  • continue 往循环的条件位置跳

else 语句

# 需求：用户输入密码，有三次机会，如果正确，登录成功
# 如果三次机会都输入错误，冻结此账户
for i in range(3):
    password = input('请输入您的密码')
    if password == '666':
        print('登陆成功！！')
        break
    else:
        print('密码不正确，请重新输入！')
else:
    print('由于您多次输入密码错误，该账户已被冻结，请联系管理员：xxx')
# 序列正常执行完毕后，else 语句就会执行

随机模块

# 1. 导入随机模块
import random

# 2. 使用 random 模块调用 randint(a, b) ，会得到a~b 之间的任意随机整数
num = random.randint(1,3)

print(f'num = {num}')

可以利用随机模块，制作一个石头剪刀布的游戏

# 石头剪刀布
# 1. 先得到电脑出的招式
import random
computer = random.randint(1, 3)
print(f"The computer is {computer}")        # 作弊

# 2. 提示用户，并输入用户的招式
Li = int(input('请输入您的招式：(1：石头，2：剪刀，3：布)'))

# 3. 判断输赢
# and 的优先级高于 or
if Li == 1 and computer == 2 or Li == 2 and computer == 3 or Li == 3 and computer == 1:
    print('Li 赢了!!')
elif Li == 1 and computer == 3 or Li == 2 and computer == 1 or Li == 3 and computer == 2:
    print('Computer 赢了!!')
else:
    print('平局!!')
weixin_51167292
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
快速学习-XXL-JOB版本更新日志
逍遥云恋
09-23 1260
七、版本更新日志 7.1 版本 V1.1.x，新特性[2015-12-05] 【于V1.1.x版本，XXL-JOB正式应用于我司，内部定制别名为 “Ferrari”，新接入应用推荐使用最新版本】 1、简单：支持通过Web页面对任务进行CRUD操作，操作简单，一分钟上手； 2、动态：支持动态修改任务状态，动态暂停/恢复任务，即时生效； 3、服务HA：任务信息持久化到mysql中，Job服务天然支持集群，保证服务HA； 4、任务HA：某台Job服务挂掉，任务会平滑分配给其他的某一台存活服务，即使所有服务挂掉，
PVS-Studio-7.28.exe
01-02
PVS-Studio，代码静态分析工具，2023年12月版本
Python学习笔记------处理数据和生成折线图
2301_80483372的博客
05-06 369
文件可用网站abc173.com处理（更方便查看）2、去掉不合JSON规范的开头与结尾。3、设置全局配置选项、 系列配置选项。3、JSON转Python字典。点JSON相关，JSON视图。4、获取x，y轴数据。2、添加x，y轴数据。
Python暑期学习7.28
Minghao00的博客
07-28 126
Python暑期学习7.28
python爬虫学习之路
bucan804228552的博客
03-04 1356
抓取互联网上的数据，为我所用，有了大量的数据，就如同有了一个数据银行一样，下一步做的就是如何将这些爬取的数据产品化，商业化。
Python学习笔记
baidu_41656586的博客
02-23 832
Python学习笔记，包括基本的list\dict\json
python机器学习10-pandas
m0_63860007的博客
07-28 338
注意：pandas函数也能读入在云端的数据，可通过“df=pd.read_excel（'http://xxxx/test.xls'，'sheet'）”将Excel表装载。· sheet_name="sheet"：请依照实际的Excel文件的工作表填写，如果不确定可以用sheet_name=0，来可以打开第一个工作表。· read_csv：可以读入本地文件（如text.csv），也可以读入网络文件（如http://xxx/test.csv）。· df.info（）：关于DataFrame的详细信息。
周报——写代码时解决的相关问题（7.22-7.28）
qq_52245889的博客
07-28 244
知识点1：类=属性（数据）+方法（函数）知识点2：用类创建对象——会默认调用__init__()方法知识点3：通过对象调用类中的方法——self相当于C语言中的this指针注意：传参的时候并不用传self，它负责把其他参数定位到所创建对象的地址。
GitHub每周最火火火项目（7.22-7.28）
最新发布
qq_37281548的博客
07-28 332
此外，它还提供了错误处理和重试机制，提高了程序的稳定性。它提供了一个结构化的学习路径，涵盖了 Python 基础知识、数据类型、控制结构、函数、面向对象编程、模块和包、文件操作、异常处理、数据库操作、Web 开发等方面的内容。它由经验丰富的开发者构建，旨在解决 Web 开发中的常见问题，提供了一套完整的工具和库，包括数据库ORM、模板系统、表单处理、认证和授权等。项目介绍：pandas 是 Python 的核心数据分析支持库，提供了快速、灵活、明确的数据结构，旨在简单、直观地处理关系型、标记型数据。
python图形验证码识别_一起学python-opencv三十（图像验证码识别）
weixin_39832348的博客
12-03 202
上一讲我们学习的是人脸检测，只是检测到人脸所在的区域，这一讲说的是图片验证码识别，是要有识别在里面的。先介绍什么叫做OCR：利用pytesseract实现图片验证码识别我们用到的核心模块是pytesseract，关于这个模块如何配置，参考：https://www.cnblogs.com/zhangxinqi/p/9297292.html#_label1这个地方我的选择是把所有的都勾上了，当然你可以...
opencv_python-3.4.7.28-cp37-cp37m-win_amd64.whl百度云链接
03-27
opencv_python-3.4.7.28-cp37-cp37m-win_amd64百度云链接，适用于win10、python3.7版本
opencv_python-3.4.7.28-cp37-cp37m-win_amd64.whl
04-26
机器学习-计算机视觉的库 opencv_python-3.4.7.28-cp37-cp37m-win_amd64.whl
opencv_python-3.4.7.28-cp37-cp37m-manylinux1_x86_64.whl
09-26
Opencv3.4.7 python3.7在linux环境下的whl安装包。。 ，。
drools-core-7.28.0.Final.jar
05-31
流口水 :: 核心 org.drools/drools-core/7.28.0.Final/drools-core-7.28.0.Final.jar
快醒醒，别睡了!...讲《数据分析pandas库》了—/—＜4＞
qq_64603703的博客
07-27 688
详细解说数据分析pandas库中的常用方法
全网最详细Gradio教程系列5——Gradio Client: python
shao918516的博客
07-26 971
程序部署完成后，如何将Gradio App作为API访问使用呢，这就用到Gradio Client。本章讲解Gradio Client的三种使用方式：python、javascript和curl，受字数限制，所以分三篇博客发布。 使用Gradio Python Client非常易于将Gradio应用程序作为API使用，本节讲述gradio_client安装、如何连接Gradio应用程序、查看可用API及其使用方式、job及session等用法。 通过Gradio Python Cli
全面解析 SnowNLP：中文文本处理、情感分析
有勇气的牛排博客
07-24 517
SnowNLP 是一个专门用于处理中文文本的 Python库。分词情感分析关键词提取文本分类拼音转换繁体转简体词相似度计算等测试环境：Python3.10.9尚未测出该功能text = "有勇气的牛排写的文章通俗易懂，爱了爱了"文本分类使用的是 SnowNLP 的情感分析模型。
Chapter 18 Python异常
2302_80253507的博客
07-28 778
在Python中，异常是一种特定的对象，能够在程序运行过程中被抛出和处理。有效地管理异常不仅可以增强程序的稳定性，还可以提高用户体验，使程序能够优雅地处理错误情况。本章详细讲解了异常的基本概念以及如何捕获和处理异常。
一个变量x取值在[-7.13,5.36]范围之间，有什么办法使得x+一个随机公式的结果仍然在[-7.13,5.36]范围内
05-26
可以使用取余运算符（%）来实现。假设随机公式的结果为y，则可以使用以下代码实现： ``` y = # 随机公式 x = x + y % (5.36 - (-7.13)) - (5.36 - (-7.13)) / 2 ``` 其中，`(5.36 - (-7.13))`表示范围的宽度，即`12.49`。`y % (5.36 - (-7.13))`表示将`y`的值限制在`[-12.49, 12.49]`之间，然后再减去`(5.36 - (-7.13)) / 2`，即`-6.745`，将其平移到`[-7.13, 5.36]`的中心位置。这样，`x + y`的结果就始终在`[-7.13, 5.36]`范围内。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值