一 : Python简介
1 什么是Python
Python是一门优雅而健壮的编程语言,他继承了传统编译语言的强大型和通用性,同时因为借鉴了简单脚本和解释语言的易用性。
2 起源:
Guido van Rossum 于1989年底创始了Python,1991年初,Python发行了第一个公开版本
3 特点:
A 具有高级的数据结构,减少了“框架”开发时间。及标准库模板
B 面向对象:为数据和逻辑相分离的结构化和过程化编程添加了新的活力,面向对象编程支持的行为、特性以及功能与它们要处理或所代表的数据结合在一起
C 可升级:Python中你可以不断地在各个项目中完善你自己的代码,添加额外的新代码。
D 可扩展:Python的标准实现是使用C语言完成的,所以要使用C和C++编写Python扩展,Python的Java实现被称为jython,使用Java进行扩展,还有Ironpython,是针对.NET或Mono 平台的C#实现。
E 可移植性: 可以用于不同的操作系统上的操作,因为Python是用C编写的,因此其继承了C语言的可移植性
F 易学:Python关键字少,结构简单,语法清晰。
G 易读:Python与其他语言显著的差异是:他们有其他语言用来访问变量、定义代码块和进行模式匹配的命令符号,
H 易维护:源代码的维护是软件开发生命周期的组成部分,Python项目的成功很大程度上要归功于其源代码的易于维护
I 健壮性:针对错误Python提供了“安全合理“的退出机制,一旦Python由于崩溃,解释器就会传出一个“堆栈跟踪”。
J 高效的快速原型开发工具,Python有许多面向其他系统的接口,他的功能足够强大,本身也足够强壮,所以完全可以使用Python开发整个系统的原型,Python提供例如强大的扩展库,实现了“即插即用”的标准
K 内存管理器:在Python中,内存管理是由解释器负责的,而C或C++的内存管理是由开发者负责的
L 解释性和字节编译性 Python实际上是字节编译的,其结果就是可以生成一种近似机器语言的中间形式,改善了Python的性能
二 Python解释器
CPython: IPython:是在CPython的基础上增加了交互式功能 PVPY: JPython :基于Java Ironpython :.NET
Python编译工具: Python,IPython,vim
三 Python 的输入输出:
1 输入:
input(“X:”) 一般针对于数值类型的数据,
执行结果:
raw_input:而非数值类型的数据则使用raw_input进行输入
执行结果 需要添加执行权限:
2 输出:
1 使用print输出各型的
1 字符串 2 整数 3 浮点数 4 初度及精度控制 格式化输出整数
格式化输出16进制整数 %x ---hex 十六进制 %d ---dec 十进制 %o ---oct 八进制
二进制输出结果如下
格式化输出浮点数(float) 其中逗号前面的数字是该字符串的长度,小数点后面的是保留的位数。
2 format 格式化输出
1 位置参数传参,默认为按位置传递参数
In [2]: "a1={},a2={},a3={}".format(1,2,3)
Out[2]: 'a1=1,a2=2,a3=3'
In [3]: "a1={1},a2={2},a3={0}".format(1,2,3)
Out[3]: 'a1=2,a2=3,a3=1'
In [2]: "{0}{1}".format(('www','baidu.com'))
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-2-39bc09eb34c0> in <module>
----> 1 "{0}{1}".format(('www','baidu.com'))
IndexError: tuple index out of range
In [3]: "{0}{1}".format('www','baidu.com')
Out[3]: 'wwwbaidu.com'
In [4]: "{0[0]}{0[1]}".format(('www','baidu.com'))
Out[4]: 'wwwbaidu.com'
2 列表分解
In [7]: l1=[1,2,4,5]
In [8]: "a1={2},a2={3},a3={1},a4={0}".format(*l1)
Out[8]: 'a1=4,a2=5,a3=2,a4=1'
3字典分解
In [9]: d1={'k1':'v1','k2':'v3','k3':'v2'}
In [10]: "a1={k2},a2={k1},a3={k3}".format(**d1)
Out[10]: 'a1=v3,a2=v1,a3=v2'
4 对齐填充 左对齐,> 表示左填充,10 表示填充的字符长度,'x'表示填充后的结尾,默认填充物是空格
此处可用于生成相关格式化
In [139]: "{:>04}".format(10)
Out[139]: '0010'
In [11]: "{:>10}".format('x')
Out[11]: ' x'
In [12]: "{:*>10}".format('x')
Out[12]: '*********x'
右对齐,默认填充物为空格
In [14]: "{:<10}".format('x')
Out[14]: 'x '
In [15]: "{:?<10}".format('x')
Out[15]: 'x?????????'
In [32]: print ("{0}*{1}={2:<2}".format(4,5,4*5),end=" ")
4*5=20
中间对齐
In [16]: "{:?^10}".format('x')
Out[16]: '????x?????'
In [17]: "{:^10}".format('x')
Out[17]: ' x '
5 进制转换
In [18]: "{:b}".format(10)
Out[18]: '1010'
In [19]: "{:d}".format(10)
Out[19]: '10'
In [20]: "{:x}".format(10)
Out[20]: 'a'
In [21]: "{:o}".format(10)
Out[21]: '12'
6 浮点数格式化
In [23]: "{:.2f}".format(1.2455677)
Out[23]: '1.25'
In [24]: "{:.3f}".format(1.2455677)
Out[24]: '1.246'
7 应用 使用列表生成式打印99乘法表
[print ("{}*{}={:>3}{}".format(j,i,i*j,'\n' if i==j else " "),end="") for i in range(1,10) for j in range(1,i+1)]
结果如下
for i in range(1,10):
print ("{:>{}}".format('*',i))
四编码格式:
一般的输入中文时需要指定编码格式为utf-8格式才能输出中文,因为其默认的编码方式是ASCII 个不同编码方式的介绍 ASCII:1个字节表示字符,其一个字节为8位,共有2^8-1=255个不同的编码方式 Unicode: 2个字节表示一个字符,可以包含中文,编码方式为2^16-1=65535种 UTF-8:英文使用一个字节表示一个字符,其他语言使用三个字节进行存储 GB2312 指定编码方式的途径: coding:utf-8 coding=utf-8 encoding:utf-8 encoding=utf-8 以上几种方式表示的结果是相同的
++++++++++++++++++++++++++++++++++++++++++++++++++++++++
五 数据类型和变量
1 变量
变量是内存中的一块区域 变量的命名:变量名由字母。数字和下划线组成
2 数据类型
1×××:
二进制,八进制,十进制,十六进制(int)
2长整型:
3浮点数:
小数,科学计数法
4 复数:(Python特有)
5 字符串:字符,字符串
6布尔值:Ture,Flase
空值 Null 其不能被理解为0,因为0是有特殊意义的,而None是一个特殊的空值
六 运算符和表达式
1 算数运算符:
+(加) -(减) *(乘) **(次方) /(除) %(余) //
Python 2 和Python中不同的是/ 除 。Python2中5/2=2,而Python 3 中5/2=2.5
2 赋值运算符:
= 、+= 、 -= 、 /=、 *= 、 %= 、
3 关系运算符:
、>=、 <、 <=、 !=、 == 其返回值是一个布尔类型的值
4 逻辑运算符:
and (同真为真) or (同假为假) not (真为假,假为真) 结果为布尔类型
5 位运算
6 成员运算
7 身份运算
8 运算符优先级
七 注释:
单行注释使用# 多行注释使用三引号(''' ''' )或 (""" """)
三引号的作用: 1 用于多行注释: 2 用于print 多行输出
八 内置方法:
1 查找:
如何查找帮助: help(cmp) 类型转化函数: type(x)
2 cmp(1,2)
进行比较大小,前面大于后面为1,相等为0,后面大于前面为-1
3 abs(-1) 取绝对值
4 divmod(10,3) 进行取商和余数
5 pow(X,Y) 其表示为x的y次方
九 Python 语句
1 if 语句格式:
1 if 表达式:
满足表达式执行的语句
2 if 表达式:
满足表达式执行的语句
else:
不满足表达式执行的语句
3 if 表示式:
满足表达式执行的语句
elif 表达式:
满足此表达式执行的语句
......
else:
上面表达式的结果都不满足时执行的结果
三目运算符
Python不支持 a>b?a:b
Python支持 a if a>b else b a>b如果成立,则执行a,否则,执行b
———————————————————————————————————————————
2 while 循环语句
用法:
while 表达式:
满足表达式执行的语句
while 表达式:
满足表达式执行的语句
else:
不满足表达式的语句
或使用死循环
while Ture:
所有字句
```
循环语句和用户关键字
break :跳出循环
continue:跳出本次循环
———————————————————————————————————————————
## 3 生成器对象
range(X,Y)
![](https://s1.51cto.com/images/blog/201712/25/593767f76d8ed944b2b355a3bdbea42e.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
> 默认的起始位为0 ,步长为1,结束位为Y-1,可以定义起始,结束和步长。
## 4 for 循环:
C语言中的for 循环 for(i=0;i<100;i++) print i
Python中for循环的语法: for i in 可迭代对象: state1 跳出for循环:break 跳出本次循环:continue ```
十 字符串常用操作
1 创建:
单引号,双引号,三引号(转义字符 : ' '' \n \t )
更新
2 特性:
1 索引特性
2 切片特性
s[start:stop:step] start 默认为0 ,stop默认为字符串长度 ,step默认为1 ,
3 操作符
1 连接操作符(+)
2 重复操作符
3 成员操作符
in , not in 字符串是可迭代对象,可使用for 实现循环
4 字符串的格式化操作:
1 字符串的格式化符号:
2 格式化操作符辅助指令:
5 字符串常用的方法:
1 判断其字符串是由什么组成
x.isdighit()
2 判断其是有什么开头,什么结尾
注意: 其匹配是一个左闭右开区间。
3 去除空格操作
1 去除开头和结尾的空格 2 去除开头的空格 3 去除结尾空格 4 去除所有空格
4 字符串对齐格式化
左对齐,右对齐,中间对齐
5 按照指令分隔符分离字符串和修改字符串:
split : 默认替换的是空格
strip([char]) ->str 从字符串两端除去指定的字符集chars中的所有字符,如果char没有指定,去除两边的空白字符 找到能够匹配的字符,直到遇到不能匹配的为止。
其中lsplit 和 lstrip是从左边匹配 rsplit和strip 是从右边匹配 若又多个,则匹配为若有,则匹配,若第二个不满足匹配则后面的皆不匹配
a='www.aaawww.wcom'
a.strip('wac')
partition() 从左至右,遇到分割符就将字符串分割为两部分,返回头,分割符,尾部三元组,如果没找到分割符,则就返回头,2个空元素的元组 rpartition() 从右至左,遇到分割符就把字符串分割成两部分,返回头,分割符,尾三部分的元组,如果没有找到分割符,就返回2个空元素和尾部的三元组。
6 join()
python 提供了JOIN() 连接字符串join() 配合可迭代实现了多个字符串的连接十分方便。
7 指定分隔符连接信息
8 index 索引和 find 发现第一个其结果对应的索引
find在存在其元素时返回其索引,当没有其元素时返回-1
9 查看其字符串长度:
6 枚举法:
与上述相比,枚举法消耗的CPU最少
7 unicode 编码
只需要在字符前面加上一个小写的'u'即可
8 字符串的修改
replace(old,new[],count) 字符串中找到匹配替换为新字符串,并返回新字符串 count 表示替换几次,不指定就是全部替换
判断输入的一串数字中的重复的数字,并将其打印出来
n=input("请输入数字:")
if n.isdigit():
l1=10*[0] #置l1为10位的0,因为数字只有0-9十位。
for i in n:
x=int(i)
if l1[x]== 0: # 当其X对应的元素的值位0时,表示其未计入此判断语句中,若L1[X]不为1时,表示已经统计过了
l1[x]=n.count(i)
print (i,l1[x])
else:
print ("你还输入了其他字符,请重新输入")
9 bytes 和 bytearray
1 定义:
字符串与bytes 字符串是字符组成的有序序列,字符可以使用编码来理解 bytes是字节组成的有序不可变序列 bytearray 是字节组成的有序可变序列
2 编码与解码
字符串按照不同的字符集编码encode返回字节序列bytes encode(encoding='utf8',errors='steict') -> bytes 字节序列按照不同的字符集解码decode返回字符串 bytes.decode(encoding='utf-8',errors='strict') -> str bytearray.decode(encoding='utf-8',errors='strict') ->str
Unicode是全球编码,对每个国家和地区都有划分 编码 : e=bytes('abcd','utf8') f="abcd".encode() print (type(e),e,type(f),f)
解码
print (e.decode(),f.decode())
3 bytes 定义
a=bytes() #定义空不可变字节序列
type(a)
b=bytes(10) #定义被0填充的不可变字符序列
print (b,type(b))
c=bytes(range(10)) #定义[0-255]之间的int组成的可迭代对象
d=bytes([10,20,30,40])
print (type(c),c,type(d),d)
使用前缀定义 只允许基本ASCII使用字符形式b'abcd' 使用16进制表示 b"\x41\x61"
4 bytes 操作
bytes 的类型和ste相似,都是不可变数据类型,所以其方法有很多,只不过bytes的方法,输入输出都是bytes
In [3]: b'abc'.find(b'b')
Out[3]: 1
In [4]: b'abcdef'.replace(b'f',b'k')
Out[4]: b'abcdek'
类方法 bytes.formhex(string) string 必须是2个字符的16进制形式,'6162 6a 6b',空格将会忽略
In [5]: bytes.fromhex('6162 09 6a 6b00')
Out[5]: b'ab\tjk\x00'
hex()
返回16进制的字符串
```
In [9]: 'abc'.encode().hex() # 先转换成字节,然后再转换成16进制
Out[9]: '616263'
索引
In [10]: b'abcdef'[1]
Out[10]: 98
In [11]: b'abcdef'[2]
Out[11]: 99
### 5 bytearray 定义
a=bytearray() #定义一个空的可变字节序列 print(type(a),a)
b=bytearray(10) # 定义一个被0填充的可变字节序列 print (type(b),b)
c=bytearray([1,2,3,45,67,8]) #定义一个[0,255]的int组成的可迭带对象 d=bytearray(range(10)) print (type(c),c,type(d),d)
![](https://s1.51cto.com/images/blog/201905/01/bb210ac73a5dfbcb70f2dce404148723.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
e=bytearray('abcd','utf8') # 返回不可变数据类型 f="abcd".encode() print (type(e),e,type(f),f)
![](https://s1.51cto.com/images/blog/201905/01/2e1fea8073e088919a139d203cce0cb8.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
### 6 bytearray 操作
In [1]: bytearray(b'abcdef').replace(b'f',b'z')
Out[1]: bytearray(b'abcdez')
In [2]: bytearray(b'abcdef').find(b'a')
Out[2]: 0
In [3]: bytearray(b'abcdef').find(b'k')
Out[3]: -1
类方法
In [4]: bytearray.fromhex('6162 09 6a 6b00')
Out[4]: bytearray(b'ab\tjk\x00')
hex()
返回16进制表示的字符串
In [5]: bytearray('abcd'.encode()).hex()
Out[5]: '61626364'
索引
In [8]: bytearray(b'abcdef')[1]
Out[8]: 98
In [9]: bytearray(b'abcdef')[2]
Out[9]: 99
In [10]: bytearray(b'abcdef')[3]
Out[10]: 100
bytearray 操作
In [20]: x
Out[20]: bytearray(b'abcdefd')
In [21]: x.append(101) #添加,添加的是整数
In [22]: x
Out[22]: bytearray(b'abcdefde')
In [23]: x.×××ert(0,100) # 插入
In [24]: x
Out[24]: bytearray(b'dabcdefde')
In [25]: x.extend([77,78,79]) # 插入
In [26]: x
Out[26]: bytearray(b'dabcdefdeMNO')
In [26]: x
Out[26]: bytearray(b'dabcdefdeMNO')
In [27]: x.pop() # 弹出
Out[27]: 79
In [28]: x
Out[28]: bytearray(b'dabcdefdeMN')
In [28]: x
Out[28]: bytearray(b'dabcdefdeMN')
In [29]: x.remove(100) # 移除
In [30]: x
Out[30]: bytearray(b'abcdefdeMN')
In [31]: x.clear() # 清空
In [32]: x
Out[32]: bytearray(b'')
In [33]: x=bytearray(b'abcdefg')
In [34]: x.reverse() # 翻转
In [35]: x
Out[35]: bytearray(b'gfedcba')
In [1]: a=bytes(b'abcdef')
In [2]: b=bytearray(a)
In [3]: b.×××ert(0,100)
In [4]: b
Out[4]: bytearray(b'dabcdef')
### 10 python join() 方法
> python join() 方法用于将序列中的元素以指定字符串连接生成一个新的字符串
>
> 语法
> str.join(sequence)
> 参数
> sequence -- 要连接的元素序列
In [1]: str=""
In [2]: seq=['1','2','3','4']
In [3]: str.join(seq)
Out[3]: '1234'
In [4]: "".join(seq) #seq 必须是字符串序列,及可迭代对象中元素类型必须是字符串
Out[4]: '1234'
In [5]: seq=[1,2,3,4,5]
In [6]: "".join(seq)
TypeError Traceback (most recent call last) <ipython-input-6-e5f7e8c88951> in <module> ----> 1 "".join(seq)
TypeError: sequence item 0: expected str ×××tance, int found
In [7]: seq=['1','2','3','4','5']
In [8]: "".join(seq)
Out[8]: '12345'
In [16]: "!".join(seq)
Out[16]: '1!2!3!4!5'
# 十一 元组(带了紧箍咒的列表)
## 1 元组的创建:
直接进行创建
![](https://s1.51cto.com/images/blog/201712/26/6d18ec9ba85ad4d0ed19e1c2786b9267.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
其后面默认有一个逗号
当创建一个元素时必须在后面加上逗号
![](https://s1.51cto.com/images/blog/201712/26/698cf457722d3c8a199050aae77c3984.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
使用tuple进行创建无元素的元组
![](https://s1.51cto.com/images/blog/201712/26/aca94636e965398ea8c8e95d0c2a707e.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
## 2元组的删除
只能对元组进行整体删除,不能进行逐元素删除
![](https://s1.51cto.com/images/blog/201712/26/6f13cb1dbb048707dd75444a68f4c474.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
## 3 元组的操作
### 1 索引
正向索引
![](https://s1.51cto.com/images/blog/201712/26/1aa33c790c4dc95106602405c3467212.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
反向索引
![](https://s1.51cto.com/images/blog/201712/26/d0ec8d6b1c0107e5943fe26309a3be53.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
多重索引
![](https://s1.51cto.com/images/blog/201712/26/138a21aeb89cbf723626ad8a860910fb.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
### 2 切片
![](https://s1.51cto.com/images/blog/201712/26/4d55049a487c7939989805fa3f4cb708.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
### 3 连接
![](https://s1.51cto.com/images/blog/201712/26/71b793a6dbb80c163d5de0afe8af426e.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
### 4 重复
![](https://s1.51cto.com/images/blog/201712/26/3e8881105c6bc8696ba144c7ff0ad1cb.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
### 5 元组个数:
![](https://s1.51cto.com/images/blog/201712/26/8cb70f9fdeefb4a1fc8757dbae016396.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
### 6 成员操作符
in 判断成员是否存在于该组中
![](https://s1.51cto.com/images/blog/201712/26/553e54bf2de53859ccf929d89f76f81b.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
### 7 元素的循环:
可迭代对象(目前已经学习的可迭代对象有 range() 字符串 和 元组)
![](https://s1.51cto.com/images/blog/201712/26/708505eea091bf9d7814467bd5cddc9b.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
### 8 元组可用的内置方法
比较,进行一个一个的比较,当第一个相同时比较第二个,当第一个不同时直接比较出结果,前面大于后面为1,后面大于前面为-1
![](https://s1.51cto.com/images/blog/201712/26/cd60cd76f0f506da45f55cb1d1617870.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
进行元组内部各元素的比较
![](https://s1.51cto.com/images/blog/201712/26/f465c1cad69ffc28f7ec4668e671f878.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
元组的转换,可以将其他类型的数据转换成元组:
![](https://s1.51cto.com/images/blog/201712/26/c1924c2eb4b30f84859cd72a216cc6e3.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
元组的常用方法
![](https://s1.51cto.com/images/blog/201712/26/93c0e4da68b4b10ddf97bc346e85689f.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
# 十二 实例
## 1 99乘法的反向打印
for i in range(9,0,-1): for j in range(i): print ("",end="") for z in range(1,i+1): print ("{0}{1}={1:<2}".format(z,i,iz),end=" ") print ()
查看结果
![](https://s1.51cto.com/images/blog/201905/07/ca83ad1df82bfb36cc3ccccb7a3d59f7.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
## 2 打印菱形
分析如下
行数 空格数 打印*数
1 4 (空格长度) 1
2 3 (空格长度) 3 2+1
3 2 (空格长度) 5 3+2
4 1 7 4+3
5 0 9 5+4
6 1 7 6+1
7 2 5 7+-2
8 3 3 8+-5
9 4 1 9+-8
for i in range(1,10): if i<=5: print ((5-i)" "+(2i-1)"" + (5-i) " ") else: print ((i-5)" "+(19-2i)""+(i-5)" ")
查看结果
![](https://s1.51cto.com/images/blog/201904/26/b43820c6431c811629c2212677f73817.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
## 3 打印空心正方形
n=int(input("请输入要打印的正方形的行数")) for i in range(n): if i ==0 or i ==n-1: print ("#"n) else: print ("#"+" "(n-2)+"#")
结果如下
![](https://s1.51cto.com/images/blog/201904/26/57ed49f6d19b715d49aad548a7650816.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
## 4 打印某数字以内的所有素数
import math n=int(input("请输入数字:")) if n==1: print (1) elif n==2: print(1,2) else: print (1) print (2) for i in range(3,n+1,2): # 其是素数,因此其一定是奇数,除2外 for j in range(2,math.ceil(i**0.5)): #其是素数,其累计到算数平方根后为止。 if i%j==0: break else: print (i)
查看结果
![](https://s1.51cto.com/images/blog/201904/26/e8d8415436641f8bffd85c9f86eb0571.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)