python前端基础知识总结及部分练习题

最新推荐文章于 2024-04-11 11:16:18 发布

龙文文

最新推荐文章于 2024-04-11 11:16:18 发布

阅读量1.8k

点赞数 1

分类专栏：知识总结文章标签： python基础前端 python python基础知识总结

本文链接：https://blog.csdn.net/weixin_43740471/article/details/85104213

版权

      python前端基础知识总结

知识总结

认识Python

发展历史
版本选择
- python2.7是python2的最后一个版本，到2020年将不再维护
- python3.6是python3最新的版本，是python方向的未来
- py2与py3不兼容，现在我们选择py3进行讲解，以后会对比py2和py3的区别
就业方向
- WEB后端、爬虫、运维、数据分析、机器学习、人工智能
课程体系：
- python语法基础、WEB/Linux/DB、WEB框架、爬虫/数据分析/机器学习

安装环境

python安装：
- 自定义安装(将安装目录添加系统环境变量PATH下、为所有用户安装)，然后一路NEXT即可
- 测试：启动终端(win + r => cmd)，在终端中输入python然后敲回车，看到>>>表示启动成功
  - 退出环境：exit()
pycharm安装
- 社区版，一路NEXT即可完成安装
- 启动测试：在快速启动栏中选择pycharm，看到欢迎页面表示成功
- 说明：若缺啥*.dll文件，去Windows官网下载相关软件包安装即可。

第一个程序

打开pycharm
新建一个工程
新建一个文件01-hello.py(后缀.py)，输入：print(‘Hello world!’)
运行：
- 右键 =》 Run ‘01-hello’
- 终端：python 01-hello.py
  - 记得文件的路径要写对
python执行方式
- 交互式：直接终端启动python环境，然后输入一条解析执行一条命令；关闭后无法保留执行过的代码。
  - 退出：exit() 或 quit()
- 脚本式：将所有要执行的代码放到一个文件中，然后统一执行
  - 说明：为了保留代码，以后我们都采用此方式
额外说明：代码中所有的控制语句都是英文字符

变量定义

什么是变量？
- 在程序运行过程中，其值可以改变的量。（具有名字的一段存储空间）
标识符命名规范
- 只能由数字、字母、下划线组成
- 不能以数字开头
- 不能是系统关键字(有特殊意义的语法字符串)
命名原则
- 尽量做到见名知意
- 尽量使用英文，实在不行使用全拼
- 推荐命名方式：采用小写+下划线，如：user_name

示例：
# 单一赋值
a = 10

# 统一赋值
b = c = d = 20

# 对称赋值
e, f = 30, 40

# 删除变量
del a

# 此处会报NameError错
print(a)

使用常量
- python中没有常量，通常我们会使用大写加下划线的方式模拟常量，如：USER_NAME = ‘xiaoming’

代码注释

什么是注释？
- 所谓注释就是写给开发人员看的提示说明内容；注释是给人看的，解析器会直接忽略。
为什么写注释？
- 对自己能够很快回忆起思路，对于合作伙伴可以非常方便的读懂你的意思。
怎么写注释？
- 单行注释
  单行注释
- 多行注释(模拟)
  ‘’‘注释’’’
  “”“注释”""

输入输出

输出：将特定的内容打印出来
a = 10
b = 20

# 输出：可以一次打印多个数据
# sep：多个数据的分割内容
# end：结束时的内容，默认是'\n'，表示换行
print(a, b, sep=',', end='')

输入：程序运行后，等待用户的输入，然后才能进行下一步的操作
# 获取用户输入，或阻塞程序，使用时最好给出提示信息
c = input(‘请输入你的密码:’)
```
print(c)
```

存储单位

最小数据单位是比特bit，表示一位二进制的0或1，写作’b’，是网络数据传输的基本单位
最小存储单位是字节byte，写作’B’，1B = 8b
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
2^32 = 2^10 * 2^10 * 2^10 * 2^2 = 4G

数据类型

进制转换

十进制
- 基数0~9，逢10进1
- 示例：123 = 1 * 10^2 + 2 * 10^1 + 3 * 10^0 = 100 + 20 + 3 = 123
二进制
- 基数0和1，逢2进1
- 示例：0b110100 = 2^5 + 2^4 + 2^2 = 32 + 16 + 4 = 52
- 十进制转二进制：除2取余，倒序书写
  - 22 = 0b10110
八进制
- 基数0~7，逢8进1
- 示例：0o123 = 1 * 8^2 + 2 * 8^1 + 3 * 8^0 = 64 + 16 + 3 = 83
- 八进制转二进制：八进制的1位可以表示3位二进制数
  - 0o123 = 0b 001 010 011
十六进制
- 基数0_9、AF，逢16进1
- 示例：0xAB = 10 * 16^1 + 11 * 16^0 = 160 + 11 = 171
- 十六进制转二进制：十六进制的1位可以表示4位二进制数
  - 0xABC = 0b 1010 1011 1100
计算机中是以哪种进制存储数据的，为什么？
- 二进制，因为计算机只识别二进制。具体原因：
- 稳定性高(只有0和1)、成本低(技术上容易实现)、与生活中的真假逻辑相吻合(便于解决生活中的实际问题)
原码反码补码
- 如何存储负数？
  - 最高位作为符号位：0表示正数、1表示负数
  - 虽然牺牲了最高位，但是解决了负数的表示问题，简化了硬件设计
- 原码反码和补码：是针对负数而言的(正数的三码一致)
  - 负数的反码等于数据原码的符号位不变，数据位取反
  - 负数的补码等于对应的反码加1
- 计算机中的数据都是以补码的形式存储的

数据类型

说明：编程语言中不同的数据类型都是为了解决生活中的实际问题而出现的，每种类型都有相关的运算。
python中常用数据类型：整形、浮点、布尔、字符串、列表、元组、字典、集合等
整型(int)：就是数学中的整数
浮点(float)：就是数学中的小数
# 浮点
b = 3.14
print(b, type(b))
```
# 科学计数法
c = 3.1415926e-3
print(c, type(c))
```
复数(complex)
# 复数：了解
d = 2 + 3j
print(d, type(d))
布尔(bool)：对应于生活中的真假逻辑，只有两个值True/False
空(NoneType)：空类型，只有一个值None
字符串(str)：使用引号括起来的一串字符
- 定义：一对单引号、一对双引号、三对单引号、三对双引号
- 转义：使用’’，使原来有特殊含义的字符变成普通字符，也可以在定义字符串的前面加一个’r’
列表(list)：通过[]进行定义，可以存放一系列的任意数据，是一种容器类型
lt = [1, 2, ‘hello’, 3.14, True]
```
print(lt, type(lt))
# 通过下标获取元素，有越界问题
print(lt[1])
```
元组(tuple)：通过()进行定义，可以作为容器存放任意数据，元素是不可修改的
tp = (1, 2, [3, 4, 5])
print(tp, type(tp))
# 也是通过下标进行访问
print(tp[2])
```
# 定义一个元素的元组后面要添加一个,
tp2 = (1,)
print(tp2, type(tp2))
```
集合(set)：通过{}进行定义，可以作为容器存放任意数据，但是元素是不能重复的，且是无序的
s1 = {‘李白’, ‘杜甫’, ‘白居易’, ‘王安石’, ‘苏轼’, ‘李白’}
s2 = {‘李白’, ‘李商隐’, ‘李清照’, ‘李贺’, ‘李煜’, ‘苏轼’}
```
# print(s1, type(s1))
# 交集
print(s1 & s2)
# 并集
print(s1 | s2)
# 差集
print(s1 - s2)
print(s2 - s1)

# 定义空集合不能使用{}，这是留给定义空字典使用的
# 应该使用set()
# s3 = {}
# print(type(s3))
s4 = set()
print(type(s4))
```
集合经常用于去重操作
字典(dict)：通过{}进行定义
- 元素是由键值对组成的
- 键和值之间是有’:'进行连接
- 键是唯一的，而值可以是任意的
- 示例：
  d = {‘name’: ‘dahua’, ‘age’: 18}
  print(d, type(d))
  
  可以根据键获取值
  
  print(d[‘name’])
  
  当键不存在时或报KeyError错
  
  print(d[‘height’])
  
  可以通过get方法根据键获取值，
  
  print(d.get(‘age’))
  
  当键不存在时不会报错，会返回None
  
  print(d.get(‘height’))
  
  可以设置默认值，有对应的键返回其值，没有时返回设置的默认值
  
  print(d.get(‘weight’, 75))
  
  统计元素个数，字典统计的是键值对个数
  
  print(len(d))
  print(len(s1))
  print(len(lt))
  print(len(‘helloworld’))

类型转换

隐式类型转换：混合运算、条件判断
强制类型转换：使用专门的函数进行转换
int：转换为整型
float：转换为浮点
str：转换为字符串
list：转换为列表
tuple：转换为元组
set：转换为集合
dict：转换为字典

示例：
# 转换为整数
# a = int(3.14)
# 参数1：需要转换的数据
# base：数据的进制类型，默认为十进制
# a = int(‘123’, base=8)
# a = int(‘abc’, base=16)

# 浮点
# a = float(250)

# 字符串
# a = str(123)

# 列表
# a = list('hello')
# a = list((1, 2, 3))
# a = list({1, 2, 3})
# 可以转换不会报错，但是只保留了键
# a = list({'name': 'ergou', 'age': 18})

# 元组
# a = tuple([1, 2, 3])

# 集合
# a = set([1, 2, 3])

# 字典
lt = [('name', 'dahua'), ('age', 18)]
a = dict(lt)
print(a, type(a))

类型相关操作

字符串
s1 = ‘hello’
s2 = ‘world’
# 可以使用’+'将字符串拼接在一起
s3 = s1 + s2
print(s3)

# '*'可以重复前面的字符串若干次
s4 = 'abc' * 3
print(s4)

# len函数统计字符串长度
print(len(s1))

s = 'abcdefg'
# 从开头进行提取，下标从0开始
print(s[0])
# 从末尾进行提取，下标从-1开始
print(s[-1])

# 切片
# 格式：s[开始:结束:步进]
print(s[1:3])
# 当一边的边界省略，则提取到改侧的边缘
print(s[1:])
print(s[:4])
print(s[1:-2])
print(s[:-3])
print(s[-3:])

# 指定步进值，默认为1
print(s[::2])
# 逆序提取
print(s[::-1])

# 格式化
# %s：字符串
# %d：整型
# %f：浮点
# %c：字符
name = '二狗'
like = '大花'
age = 18
print('俺叫%s,暗恋%s,她今年%d岁' % (name, like, age))

# python中特有的解决方案
print('俺叫{},暗恋{},她今年{}岁'.format(name, like, age))
print('俺叫{2},暗恋{1},她今年{0}岁'.format(name, like, age))
print('俺叫{l},暗恋{n},她今年{a}岁'.format(n=name, l=like, a=age))

列表
lt = [1, 2, 3, 4, 5]

print(lt[0])
print(lt[-1])
print(lt[1:3])
print(len(lt))

# 修改元素
lt[0] = 100

# 追加元素，将传递的元素作为一个整体(一个元素)追加到列表尾部
lt.append(200)
# lt.append([300, 400])
# 将可迭代对象的元素展开添加到列表中 （扩充）
lt.extend([300, 400])

# 插入元素，在指定位置插入元素
lt.insert(2, 250)
lt.insert(4, 250)

# 删除元素
# 根据索引号删除
del lt[0]
# 根据值进行删除，只会删除第一个
lt.remove(250)
# 返回并删除：返回并删除指定下标的元素，默认是最后一个
ele = lt.pop(2)
# print(ele)
# print(lt)

lt = [1, 2, 3, 4, 5, 3]
# 查询元组在列表中的索引号
# 找到就会返回其索引号，即第一个出现的位置
# 若不在列表中则会报错
print(lt.index(3))
# 统计元素在列表中出现的次数
print(lt.count(3))

# 逆序
lt.reverse()

# 排序
# reverse=True表示降序排序
lt.sort(reverse=True)
print(lt)

ASCII

说明：美国信息交换标准代码，就是用一个数字表示一个字符的规范
转换函数：
# 字符 => ASCII
print(ord(‘A’))
# ASCII => 字符
print(chr(97))

运算符与分支结构

运算符

赋值运算符
- 用’='表示，左边只能是变量。
算术运算符
- +、-、*：加、减、乘
- /：除法，结果是浮点数
- //：除法，结果是整数
- %：求余
- **：求幂，也可以使用函数pow
复合运算符
- +=、-=、*=、…
- 示例：a += b等价于a = a + b
关系运算符
- 、>=、<、<=、==、!=
- 表达式：由运算符和操作数构成的式子
- 关系表达式：由关系运算符和操作数构成的式子
- 关系表达式式有值的：符合数学逻辑值为真(True)，不符合数学逻辑值为假(False)
逻辑运算符
- 说明：逻辑运算就是用来合并或取反表达式的
- 运算：与、或、非
- 与(and)：两边的表达式同时为真，结果才为真
  a = 200
  其他语法也通用的写法
  print(a > 10 and a < 100)
  python中特有的形式
  print(10 < a < 100)
  print(a%3 == 0 and a%5 == 0)
- 或(or)：两边的表达式一个为真，结果就为真
  y = int(input(‘请输入一个年份:’))
  print((y%40 and y%100!=0) or (y%4000))
- 非(not)：用于取反表达式，真变假，假变真
  - 使用not是为了简化表达式的书写
  - 经常伴随着隐式类型转换
成员运算符
- in、not in：判断一个值是否在另一个里面
- 说明：经常用在字符串、列表、元组、集合、字典等成员的判断
- 示例：
  lt = [1, 2, 3]
  print(8 not in lt)
  dt = {‘name’:‘dahua’, ‘age’: 18}
  对于字典，判断的是键
  print(‘name’ in dt)
位运算符(了解)
- &：按位与，对应的数据位同时为1，结果上对应的位才为1
- |：按位或，对应的数据位一个为1，结果上对应的为就为1
- ^：按位异或，对应的数据位相同是结果为0，不同时结果为1
- ~：按位取反，数据的每一位0变1，1变0
- <<：按位左移，左移一位相当于乘以2
- ：按位右移，右移一位相当于除2
运算符的优先级与结合性
- 语法中没有明确规定优先级与结合性，即使是明确说明了你也记不住
- 建议：使用时不用刻意记录优先级与结合性，当需要明确指定时添加括号即可

流程控制

说明：
- 按照代码的执行流程，程序可以分为三种结构：顺序结构、分支结构、循环结构
- 顺序结构：代码按照从上到下的顺序依次执行的结构，没有语法要求
- 代码层次：python中的代码层次不是通过大括号表示的，而是通过缩进体现的
分支结构(if-elif-else)
- 格式1：适合于解决生活中的条件执行问题
  if 表达式:
  语句块
  执行流程：当程序执行到if语句时，首先会判断表达式的真假。若表达式的值为真，则执行后面缩进的语句块；若表达式的值为假，则跳过语句块，执行后面的内容。
- 格式2：适合于解决生活中的非此即彼的问题
  if 表达式:
  语句块1
  else:
  语句块2
  执行流程：当程序执行到if-else语句时，首先会判断表达式的真假。若表达式的值为真，则执行语句块1；若表达式的值为假，则执行语句块2.
- 格式3：适合于解决生活中的多种选择问题
  if 表达式1:
  语句块1
  elif 表达式2:
  语句块2
  …
  else:
  语句块n
1. elif的个数没有限制
2. else可以省略不写
3. 所有的互斥选择语句块最多只能执行一个

相关类型操作

字符串切片
列表操作
元组操作
# tp1 = (1, 2, 3)
# tp1 = (1,)
tp1 = 1, 2, 3
tp2 = (4, 5, 6)
# 可以直接拼接在一起
# tp3 = tp1 + tp2
# print(tp3, type(tp3))
# 重复指定次数
tp4 = tp1 * 3
print(tp4)
# 统计元素个数
print(len(tp4))
tp = (1, 2, 3, 4, 5, 6)
# 切片操作
print(tp[0], tp[-1])
print(tp[1:-1])
# 获取指定元素的索引
print(tp.index(3))
# 统计元素出现的次数
print(tp.count(3))
# 最大值
print(max(tp))
# 最小值
print(min(tp))

集合操作
s = {‘彦炯’, ‘露露’, ‘彦博’, ‘启明’, ‘吕威’, ‘二狗’}

# 添加元素
s.add('继光')

# 删除元素
# s.remove('二狗')
# 删除不存在元素会报KeyError错
# s.remove('狗蛋')
# 删除元素，元素存在则删除，不存在也不报错
s.discard('狗蛋')

# 返回并删除，元素是随机的
# print(s.pop())

# 清空元素
s.clear()

# print(s)

s1 = {'小马', '小乔', '小周'}
s2 = {'小王', '小杜', '小马', '小乔', '小周'}

# 并集
# print(s1.union(s2))

# 交集
# print(s1.intersection(s2))
# 求交集，并用交集覆盖原来的集合
# s1.intersection_update(s2)

# 差集
# print(s1.difference(s2))
# 求差集，并用差集覆盖原来的集合
# s1.difference_update(s2)
# print(s1)

# 判断是否没有交集
print(s1.isdisjoint(s2))
# 判断是否是另一集合的子集
print(s1.issubset(s2))
# 判断是否是另一集合的父集/超集
print(s2.issuperset(s1))

字典操作
d = {‘name’: ‘xiaoming’, ‘age’: 20}

# 获取元素
# 有就返回对应的值，没有就报KeyError错
print(d['name'])
# 有就返回对应的值，没有就返回None，可以指定默认值
print(d.get('namexxx', '默认值'))

# 修改元素
# 键存在则修改对应的值
d['name'] = '二狗'
# 键不存在则添加键值对
d['height'] = 180

# 更新：存在的键会覆盖，不存在的键会添加
d.update({'name': 'dahua', 'weight': 50})

# 删除元素
# del d['weight']
# 返回并删除
print(d.pop('weight'))

# 清空元素
d.clear()

print(d)

练习

从终端获取一个表示年份的整数，判断是否是闰年，是就打印xxx年是闰年，不是就打印xxx年是平年

'''a=int(input('请输入一个年份'))
if (a % 4 ==0 and a % 100!=0) or (a % 400==0):
    print(a,'年是闰年')
else:
    print('是平年')'''

输入两个整数，打印较大值

'''a = (8,20)
print(max(a))'''

'''a = int(input('请输入第一个数字'))
b = int(input('请输入第二个数字'))
if a > b:
    print(a)
else:
    print(b)'''

输入三个整数，按照从小到大的顺序打印

# a = int(input('请输入第一个整数：'))
# b = int(input('请输入第二个整数：'))
# c = int(input('请输入第三个整数：'))
# lt=list((a,b,c))
# lt.sort()
# print(lt)

输入一个整数，判断其是否能同时被3和7整除

'''a = int(input('请输入一个数字'))
if a % 3 ==0 and a % 7 ==0:
    print(a,'能被3和7整出')
else:
    print(a,'不能被3和7整除')'''

输入一个字符，是大写转换为小写，小写转换为大写，其他字符保持不变，然后输出

ch = input('亲输入一个字符:')
asc = ord(ch)
#if 65<=asc<=90: #判断字符大小写
if 'A'<= ch <='Z':
    print('是大写,转换后:',chr(asc+32) )
#elif 97<=asc<=122: #判断字符大小写
elif 'a'<= ch <='z':
    print('是小写,转换后：',chr(asc-32))
else:
    print(ch)

循环结构

循环结构(while)

格式：
while 表达式:
语句块
执行流程：当程序执行到while语句时，首先判断表达式的真假。若表达式的值为真，则执行缩进的语句块，之后返回表达式继续判断；若表达式的值为假，则跳过缩进的语句块执行。
说明：
- 表达式：也叫循环条件
- 语句块：也叫循环体
- 死循环：循环条件一直成立
- break：跳出循环
- continue：结束本次循环，进入下次循环
- else：对应的语句块，循环正常退出时会执行，非正常退出(break)时不执行

循环结构(for-in)

说明：也是一种循环结构，经常用于便利可迭代对象，如：字符串、列表、元组、字典等
格式：
for x in y:
语句块
执行流程：x一次代表y种的一个元素，遍历结束循环也就结束了。

列表生成式

range：
# 一个对象，保存了产生连续整数的算法，可以节约空间
# 可以指定起始位置，默认为0
# print(range(10))
```
# 可以进行遍历
for i in range(10):
    print(i)

# 可以转换为列表
print(list(range(2, 10)))
```
列表生成式
# 列表生成式：可以快速方便地生成列表
print([i for i in range(1, 11)])
print([i for i in ‘abcdefg’])
print([i2 for i in range(1, 11)])
print([ii for i in range(1, 11)])
print([str(i) for i in range(1, 11)])
print([i for i in range(1, 11) if i % 2 == 0])
# 生成的列表可以与遍历的内容没有一毛钱关系
print([250 for i in range(1, 11)])

循环嵌套

循环能否嵌套
- 答：能
循环嵌套示例
# 外层循环控制打印多少行
for i in range(1, 11):
# print(’’ * i)
# 内存循环控制每一行多少个
for j in range(i):
print(’’, end=’ ')
print()
练习：使用while实现一遍
思考：列表排序实现，冒泡排序法思路(升序排序)
lt = [8, 3, 6, 9, 5, 2, 4, 1, 7]
第一轮：[3, 6, 8, 5, 4, 1, 7, 9]
第二轮：[3, 6, 5, 4, 1, 7, 8, 9]
第三轮：[3, 5, 4, 1, 6, 7, 8, 9]
- 参考示例：
  
  冒泡排序：升序排序
  
  lt = [8, 3, 6, 9, 5, 2, 4, 1, 7]
  n = len(lt)
  
  外出循环控制排序多少轮
  
  for i in range(n-1):
  # 内存循环控制相邻两个元素的比较
  for j in range(n-1-i):
  if lt[j] > lt[j+1]:
  # 通用交换元素方式
  # temp = lt[j]
  # lt[j] = lt[j+1]
  # lt[j+1] = temp
  # python中特有方式
  lt[j], lt[j+1] = lt[j+1], lt[j]
  
  print(lt)
选择排序
思路：先取出一个位置，用该位置的元素与后面的所有元素挨个比较，不合适就发生交换。
示例：lt = [8, 3, 6, 9, 5, 2, 4, 1, 7]
第一轮：1, 8, 6, 9, 5, 3, 4, 2, 7
第二轮：1, 2, 8, 9, 6, 5, 4, 3, 7
第三轮：1, 2, 3, 9, 8, 6, 5, 4, 7

字符串操作

切割与拼接
s = ‘I love you more than i can say’
# 切割字符串
# sep：指定按照什么进行切割，默认按照空格切割
# maxsplit：指定最大切割次数，默认不限制次数
# ret = s.split(sep=‘abc’, maxsplit=1)
# 从右边进行切割
ret = s.rsplit(’ ', maxsplit=1)
print(ret)
```
s = 'Hello\nworld'
# 按照换行进行切割
print(s.splitlines())

s = 'I love you more than i can say'
ret = s.split()
# print(ret)
# 字符串拼接
s2 = '*'.join(ret)
print(s2)
```

查找统计判断
s = ‘Hi buddy, if you have something to say, than say; if you have nothing to say, than go.’

# 子串查找：找到首次出现的位置，返回下标，找不到返回-1
# ret = s.find('hello')
# 从后面查找
# ret = s.rfind('to')
# 统计子串出现的次数
# ret = s.count('if')
# 判断是否已指定内容开头
# ret = s.startswith('Hi')
# 判断是否已指定内容结尾
ret = s.endswith('go.')
print(ret)

转换及替换
s = ‘hellO worlD!’
# 转换为全大写
print(s.upper())
# 转换为全小写
print(s.lower())
# 大小写转换
print(s.swapcase())
# 首字母大写
print(s.capitalize())
# 每个单词首字母大写
print(s.title())
# 用指定的内容替换指定内容，还可以值替换次数
print(s.replace(‘l’, ‘L’, 2))
类型判断
s = ‘abcABC2’
# 是否是全大写
print(s.isupper())
# 是否是全小写
print(s.islower())
# 是否每个单词首字母都大写
print(s.istitle())
# 是否是全数字字符
print(s.isdecimal())
# 是否是全字母
print(s.isalpha())
# 是否全是字母或数字
print(s.isalnum())

练习

计算1~100之间所有整数的和

'''a = 0
i = 0
while a < 100:
    a+=1
    i+=a
print(i)'''

打印字符A~Z

  print([chr(i) for i in range(ord('A'),ord('Z')+1)])

循环输入10个字符，大写转小写，小写转大写，其它字符不变，然后输出

'''a = 1
while a<=10:
    ch = input('亲输入一个字符:')
    asc = ord(ch)
    # if 65<=asc<=90: #判断字符大小写
    if 'A' <= ch <= 'Z':
        print('是大写,转换后:', chr(asc + 32))
    # elif 97<=asc<=122: #判断字符大小写
    elif 'a' <= ch <= 'z':
        print('是小写,转换后：', chr(asc - 32))
    else:
        print(ch)
    a+=1'''

将12345转换为54321

n = 12345
ret = 0
while n :
    #获取最后一位
    last = n % 10
    #求商

最低0.47元/天解锁文章

龙文文

关注

1
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
python前端基础知识总结及部分练习题

python前端基础知识总结知识总结认识Python发展历史版本选择python2.7是python2的最后一个版本，到2020年将不再维护python3.6是python3最新的版本，是python方向的未来py2与py3不兼容，现在我们选择py3进行讲解，以后会对比py2和py3的区别就业方向WEB后端、爬虫、运维、数据分析、机器学习、人工智能课...
复制链接

扫一扫