python基本语法

王来钱儿

已于 2023-06-27 20:37:18 修改

阅读量112

点赞数

分类专栏： python学习文章标签： python

于 2023-06-24 13:45:32 首次发布

本文链接：https://blog.csdn.net/weixin_69240989/article/details/131360948

版权

python学习专栏收录该内容

7 篇文章 0 订阅

订阅专栏

好吧，已经两天半了，第二章内容有点多，看来原计划一天一章不太现实，那就尽量多看咯，不追求速度，但求质量。

变量的定义

变量名：数字，字母，下划线，数字不能作为开头字符，区分大小写，允许中文

test='Hello'#字符串型变量
Test=345#整型变量
_TEST=3.4#浮点型变量
print(test,Test,_TEST)

   Hello 345 3.4

name,age=age,name#修改多个变量的值：互换name与age的值
print(name,age)#赋值运算，先计算等号右边的，再赋给等号左边

   100 王

数据类型：number数字，string字符串，list列表，tuple元组，set集合，dictionary字典等

number数据类型：int整型，float浮点型，complex复数类型

整型：正整数，0，负整数，无大小限制

a,b,c=10,0o10,0x10#十进制，八进制，十六进制
print(a,b,c)

        10 8 16

boolean类型，布尔类型，整型的子类型

a=True+1#True作为整型返回1
print(a)

a=False-1#False作为整型返回0
print(a)

-1

使用bool函数将其它数据类型转化为boolean类型

a=bool(None)#定义为假的常量，bool函数输出为0
b=bool(False)
print(a,b)

   False False

a=bool(0)#任意值为0的数值，bool函数输出0
b=bool(0.0)
c=bool(0j)
print(a,b,c)

   False False False

a=bool('')#空的序列或集合，bool函数输出0。字符串
b=bool([])#列表
c=bool(( ))#元组
d=bool({ })#集合
e=bool(dict( ))#字典
print(a,b,c,d,e)

    False False False False False

浮点型

b=2
b=float(b)
print(b)

2.0

b=3.25e4#科学计数法
print(b)

    32500.0

查看浮点数的取值范围和精度

import sys#导入sys包
sys.float_info#查看当前环境中浮点型数字的取值范围和精度
#max和min是浮点数的最大值最小值，dig是浮点数能精确表示的十进制数字的最大位数

sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

复数类型

a=3+4j
b=complex(2,1)
c=complex(3,)
d=complex(3)
e=complex()
#f=complex( ,2)报错
f=complex(0,2)
g=3.25e5j
print (a,b,c,d,e,f,g)

    (3+4j) (2+1j) (3+0j) (3+0j) 0j 2j 325000j

c1,c2,c3,c4,c5=3+5.2j,complex(),complex(2,4.3),complex(2),9j
print(c1,c2,c3,c4,c5)

    (3+5.2j) 0j (2+4.3j) (2+0j) 9j

string数据类型

a,b,c='d',"d",'''d'''#字符串可以写在一对单引号，双引号，三双引号中
e=''#空字符串
f=str(9)#str函数讲9转化为string类型
print(a,b,c,e,f)

    d d d  9

字符串转成整数

#第一个参数是要转换为整数的字符串，该字符串必须是整数字符串。第二个参数为字符串中整数的数制，默认为10
a=int('24')
b=int('24',6)#输出为10进制，所以将6进制的24输出为其10进制数16
#c=int('24+1')报错，区分于eval('24+1'),eval可以计算字符串表示的运算式
print(a,b)

    24 16

字符串转成浮点数

#只有一个参数，字符串内容必须是整数或浮点数
a=float('44.5')
b=float('44')
#c=float('44.3+8')会报错，区别于eval('44.2+1.8')
print(a,b)

    44.5 44.0

a=str('')
#b=float(a)报错
b=bool(a)#空字符串先转换为boolean型，boolean型作为整型为0，再转换成浮点型
c=float(b)
print(c)

0.0

常用转义字符

print('Hello\
World')#|一行代码
print("eat\\sleep")#反斜线
print('Hi，\'傻瓜\'')#单引号
print('她说:"爱你"')#因为字符串用单引号，故双引号不用写为|"
print("你好！\n欢迎来到智慧树乐园！")#换行
print("abcdefgh\ri")#回车：\r后面个数大，则输出后面；\r后面个数小，则\r前面的后面个数个删掉，输出|r后面+\r前面剩的
print("Hello\tWorld")#制表符

    HelloWorld
    eat\sleep
    Hi，'傻瓜'
    她说:"爱你"
    你好！
    欢迎来到智慧树乐园！
    ibcdefgh
    Hello        World

子串截取

#字符串的下标从左至右为0123456…，从右至左为-1，-2，-3…
s='abcdefghijklmn'#定义字符串
a,b,c,d=s[1:6],s[3:],s[:5],s[:]#截取格式：字符串[起始位置：终止位置]，输出下标为起始-（终止-1）
print(a,b,c,d)#第一个字符下标为0，所以输出内容为（起始+1）-终止位置上的字符
e,f,g,h,i,j=s[-7:-1],s[-4:],s[-7:-2],s[-7:],s[2:-3],s[4]#输出下标为起始-（终止-1）
print(e,f,g,h,i,j)#输出内容为起始-（终止-1）位置上的字符

    bcdef defghijklmn abcde abcdefghijklmn
    hijklm klmn hijkl hijklmn cdefghijk e

获取单一字符

s='abcdefghijklmn'
#s[2]='k'报错，获取单一字符只能访问那个字符，不能修改
print(s[3])#下标为3的是字符中的第4个
print(s[-5])#下标为-5的是字符中的倒数第5个

    d
    j

list数据类型,[ , , ],其中每一元素可以是任意类型,包括列表，称为列表嵌套

a=list([1,3.4,3+2j,'abandon',False,list([complex(3,6),float(4)])])#元素类型为int,float,complex,string,boolean,list。6个元
b=[]#空列表
print(a,b)

    [1, 3.4, (3+2j), 'abandon', False, [(3+6j), 4.0]] []

列表元素索引，大部分与string一样，区别为列表可以修改

a=list([1,3.4,3+2j,'abandon',False,list([complex(3,6),float(4)])])
b,c,d,e=a[1:4],a[:3],a[4:],a[2]#前三个返回仍为列表，第四个为一个元素，不一定是列表
f,g=a[5:6],a[5]#f为列表，g为一个元素，正好这个元素是列表
print(b,c,d,e)
print(f,g)

        [3.4, (3+2j), 'abandon'] [1, 3.4, (3+2j)] [False, [(3+6j), 4.0]] (3+2j)
        [[(3+6j), 4.0]] [(3+6j), 4.0]

a[2]="wang"#修改单一元素
print(a)

        [1, 3.4, 'wang', 'abandon', False, [(3+6j), 4.0]]

a[2:5]=[False,3e4]#修改一串3元素为2元素
print(a)#科学计数法是浮点型

        [1, 3.4, False, 30000.0, [(3+6j), 4.0]]

a[2]=['abandon',True]#修改单一元素为单一元素
print(a)

        [1, 3.4, ['abandon', True], 30000.0, [(3+6j), 4.0]]

a[1:3]=[]#把原列表中第2,3元素改为空列表，即删除
print(a)

        [1, 30000.0, [(3+6j), 4.0]]

tuple数据类型：( , , )元素类型可以不相同，与string一样不可修改,索引方式与string相同

a=(1,3.5,'abandon',True,[1,False],(1,3.4))#该元组中元素数据类型分别为int,float,string,boolean,list,tuple
b=()#空元组
print(a,b)

        (1, 3.5, 'abandon', True, [1, False], (1, 3.4)) ()

a=a[1:4]#索引方式与string相同
print(a)

        (3.5, 'abandon', True)

序列：可以通过下标直接访问元素的数据类型(string,list,tuple),其中string与tuple中元素不可修改，可哈希；list元素可修改，不可哈希

set数据类型，{ , , }元素类型必须可哈希,即为string和tuple，且元素无序不重复,不可通过下标访问元素

a={6,3.2,3+4j,'app',True,6,(2,3)}#普通定义集合方法,其中元素数据类型为int,float,complex,string,boolean,tuple。6重复所以输出只有一个6
b=set({1,2})#set函数定义集合
c=set()#空集合，{}是空字典，不是空集合
print(a,b,c)

        {(2, 3), True, 3.2, '6', 6, 'app', (3+4j)} {1, 2} set()

a={0,True}
b={1,True}#python中1=True
print(a,b)

        {0, True} {1}

a={0,False}#python中0=False
b={1,False}
print(a,b)

        {0} {False, 1}

a=set('hello')#set(字符串)
print(a)
b=set((0,3.4,(1,3.4,'String'),True,'Hello',3.4))#set(元组)
print(b)
c=set([1,3.4,(1,3.4,'String'),True,8])#set(列表)，且有true有1，只输出1
print(c)

        {'l', 'e', 'o', 'h'}
        {0, (1, 3.4, 'String'), True, 3.4, 'Hello'}
        {8, 1, 3.4, (1, 3.4, 'String')}

dictionary数据类型:无序，{键:值,键:值,键:值}，键各不相同且可哈希，即string或tuple，值可以任意类型

a={}#空字典，普通定义字典
b=dict()#空字典,dict函数定义字典
print(a,b)

        {} {}

a={'one':1,2:2}#创建字典：赋予键与值
e=dict({'one':1,2:2,(1,True):()})#与a一样，只不过是用dict函数
b=dict(one=1,app=100)
#b=dict(1 = '3',2 = 'a',3 = 'three')报错b=dict(one=1,app=100,('app',(1,3.4))=100)报错
c=dict(zip([1,2,'one'],[4,3,[1,(True,'app')]]))#zip函数：zip([ , , ],[ , , ])键为int,int,string。值为int,int,tuple
d=dict([(1,1),((1,'app'),2),('one',(True,'p'))])#dict([(键,值),(键,值),(键,值)])键分别为:int,tuple,string值分别为:int,int,tuple
print(a,e,b,c,d)

        {'one': 1, 2: 2} {'one': 1, 2: 2, (1, True): ()} {'one': 1, 'app': 100} {1: 4,         2: 3, 'one': [1, (True, 'app')]} {1: 1, (1, 'app'): 2, 'one': (True, 'p')}

a=list(zip([1,2,3],['one',2,3]))#zip函数返回一个对象，可用list函数转换为列表
print(a)

        [(1, 'one'), (2, 2), (3, 3)]

访问字典元素，不能通过下标，而是通过键

a=dict(zip(['name','age','gender','height'],['wang',100,'man',200]))#定义字典：都是一对一
print(a['name'],a['height'])

        wang 200

a=dict(zip(['name','age','score'],['王','1',{'math':1000,'eng':2000}]))#定义字典：前两个是一对一，最后一个是一对一个字典
print(a['name'],a['score']['eng'])#访问字典中的字典的值

        王 2000

占位运算符

%d整型十进制，%f浮点型十进制，%s字符串

print('%s数学成绩为%d,上次成绩为%d，成绩提高率为%f'%('小王',90,85,5/90))#格式：想输出的内容%(对应占位符处想填的内容)
print('%4s数学成绩为%5d,上次成绩为%3d，成绩提高率为%.2f'%('小王',90,85,5/90))#字母前数字是一共占几位,输出用空格填满，.2为小数点后位数
print('%04s数学成绩为%25d,上次成绩为%13d，成绩提高率为%8.2f'%('小王',90,85,5/90))#数字部分输出用0填满,不能用2填，字符串部分仍用空格填
#8.2为小数共占8位,小数点后2位
print('%4s数学成绩为%05d,上次成绩为%03d，成绩提高率为%08.2f'%('小王',90,85,5/90))#小数的整数部分用0填满

小王数学成绩为90,上次成绩为85，成绩提高率为0.055556
  小王数学成绩为   90,上次成绩为 85，成绩提高率为0.06
  小王数学成绩为                       90,上次成绩为           85，成绩提高率为    0.06
  小王数学成绩为00090,上次成绩为085，成绩提高率为00000.06

print('班级总人数：%d人，此次考试通过率为%f%%'%(100,99/100))#有占位符的字符串表示%要写为%%
print('%')#没有占位符的输入%即可

班级总人数：100人，此次考试通过率为0.990000%
%

算术运算符+,-,*,/,//(商),%(余数),-(负号),+(正号),**(乘方)

print(eval('3+5'),eval('7//4'),7/4,7%4,1.5*1.8,+(-3),3**3)

8 1 1.75 3 2.7 -3 27

赋值运算符=,+=,-=,*=,/=,//=,%=,**=

a,b,c,d,e,f,g,h=1,2,3,4,5,6,7,8
a+=b#a=a+b
b-=c#b=b-c
c*=d#c=c*d
d/=e#d=d/e
e//=f#e=e//f
f%=g#f=f%g
g**=h#g=g**h
print(a,b,c,d,e,f,g)

3 -1 12 0.8 0 6 5764801

比较运算符==,!=,>,<,>=,<=

a,b,c=13,43,13
print(a==b,a==c)
print(a!=b,a!=c)

False True
True False

逻辑运算符and(与)or(或)not(非)

print(a<10 and b>40)#and一假则假:假and真=假
print(a>10 or b<40)#or一真则真：真or假=真
print(not(a>10))#取反：not(真)=假
print(not 0)#0作为Boolean型是false，故输出not(false)
print(not 1)#1作为boolean型是true,故输出not(true)

False
True
False

十进制转二进制：除基取余法：十进制数一直除2，除到0，二进制数为其余数从后至前得到的排列

#26/2=13/2=6…1/2=3/2=1…1/2=0…1，所以26的二进制为11010

二进制转十进制：按权求和展开：∑数码*位权

#二进制数11010B=1*(2**4)+1*(2**3)+0*(2**2)+1*(2**1)+0*(2**0)=26

位运算符：对二进制数进行逐位运算&(与)|(或)^(异或)<<(左位移)>>(右位移)~(取反)

print(24&7)#24=11000B,7=111B,按位与：一假则假：00000B=0
print(24|7)#按位或：一真则真：11111B=31
print(24^7)#按位异或：不一样则1，一样则0:11111B=31
print(24<<1)#左移1位，用0补：110000B=2**5+2**4=48
print(24>>1)#右移1位：1100B=2**3+2**2=12
print(~24)#取反:24=(0)0b11000:正数(0)。取反:(1)0b00111。减一:(1)0b00110。取反:(1)0b11001=-(2**4+2**3+2**0)=-25

身份运算符:比较两对象是否对应同样的存储单元is,is not

a,b=12,12
print(a is b)
print(a is not b)#相同数字存储单元相同
print(a is 12)#相同数字存储单元相同

True
False
True

警告但不报错

<>:4: SyntaxWarning: "is" with a literal. Did you mean "=="?
<>:4: SyntaxWarning: "is" with a literal. Did you mean "=="?
C:\Users\lenovo\AppData\Local\Temp\ipykernel_29208\1340517286.py:4: SyntaxWarning: "is" with a literal. Did you mean "=="?
  print(a is 12)

a,b='one','one'
print(a is b)#相同字符串，存储单元相同
print(a==b)
print(a is 'one')#相同字符串，存储单元相同

True
True
True

警告但不报错

<>:4: SyntaxWarning: "is" with a literal. Did you mean "=="?
<>:4: SyntaxWarning: "is" with a literal. Did you mean "=="?
C:\Users\lenovo\AppData\Local\Temp\ipykernel_29208\1710091875.py:4: SyntaxWarning: "is" with a literal. Did you mean "=="?
  print(a is 'one')#相同字符串，存储单元相同

a,b=[1,2,3],[1,2,3]
print(a is b)#相同列表，存储单元不同
print(a==b)
print(a is not b)
print(a is[1,2,3])#相同列表，存储单元不同

False
True
True
False

a,b={1,3},{1,3}
print(a is b)#相同集合，存储单元不同
print(a==b)
print(a is {1,3})#相同集合，存储单元不同

False
True
False

a,b={'one':1,'two':2},{'one':1,'two':2}
print(a is b)#相同字典，存储单元不同
print(a==b)
print(a is {'one':1,'two':2})#相同字典，存储单元不同

False
True
False

a,b=(1,3),(1,3)
print(a is b)#相同元组，存储单元相同
print(a==b)
print(a is(1,3))#相同元组，存储单元不同

True
True
False

警告但不报错

<>:4: SyntaxWarning: "is" with a literal. Did you mean "=="?
<>:4: SyntaxWarning: "is" with a literal. Did you mean "=="?
C:\Users\lenovo\AppData\Local\Temp\ipykernel_29208\2121919848.py:4: SyntaxWarning: "is" with a literal. Did you mean "=="?
  print(a is(1,3))#相同元组，存储单元不同

成员运算符,判断可迭代对象(可逐个取出)(序列(可按下标取出):string,list,tuple。集合，字典)中是否包含某元素，in，not in

a,b='12','t5dfxc56712vbdf'#string
print(a in b)
print(a not in b)
a,b=3,list([1,True,'apple',9,3])#list
print(a in b)
a,b='apple',(4,'apple')#tuple
print(a in b)
a,b=(3,'apple'),{1,4.4,9+3j,'apple',(3,'apple')}#set
print(a in b)
a,b='one',dict(zip([1,'one',2],['apple',3,'one']))#dictionary,通过判断是否为该字典的键来判断
print(a in b)
a,b='one',([1,'one',2],['apple',3,'one'])#想定义字典，字典定义方法错误，成了元素为两个列表的元组
print(a,b,a in b)

True
False
True
True
True
True
one ([1, 'one', 2], ['apple', 3, 'one']) False

序列运算符(可按下标取出)string,list,tuple,+(拼接),(重复)

a,b='i love',' myself'#string
print(a+b)
print(a*3)
a,b=[[1,2],'apple',True],['ai',2.5]#list
print(a+b)
print(a*5)
a,b=(1,2,'aaa'),(True,[1,2,'apple'])#tuple
print(a+b)
print(b*3)

i love myself
i lovei lovei love
[[1, 2], 'apple', True, 'ai', 2.5]
[[1, 2], 'apple', True, [1, 2], 'apple', True, [1, 2], 'apple', True, [1, 2], 'apple', True, [1, 2], 'apple', True]
(1, 2, 'aaa', True, [1, 2, 'apple'])
(True, [1, 2, 'apple'], True, [1, 2, 'apple'], True, [1, 2, 'apple'])

运算符优先级

（乘方） ~，+，-（按位取反，正号，负号），/，//，%（乘，除，商，余） +，-（加，减） <<，>>（按位左移，按位右移） &（按位与） ^（按位异或） |（按位异或） <，>，<=，>=，==，!=。is，is not。in，not in（比较运算符，身份运算符，成员运算符） =，+=，-=，=，/=，//=，%=，=（赋值运算符） not（逻辑非） and（逻辑与） or（逻辑或）

条件语句：流程图，伪代码，if，elif，else

score=eval(input('请输入成绩：'))#输入字符串，eval将字符串转换成数字赋给score
if score<60:
    print('不及格')

请输入成绩：10
不及格

score=eval(input('请输入成绩：'))#eval将字符串转换成数字赋给score
if score<60:
    print('不及格')
else:
    print('good')

请输入成绩：59
不及格

score=eval(input('请输入成绩：'))#eval将字符串转换成数字赋给score
if score<60:
    print('不及格')
elif score<70:
    print('勉强')
elif score<80:
    print('凑合')
elif score<90:
    print('不错')
else:
    print('牛逼')

请输入成绩：90
牛逼

score=eval(input('输入成绩'))
if score<60:#每个语句序列中可以包含多条语句
    print('你的成绩为%d'%score)
    print('把你妈叫来')
else:
    print('你的成绩为%d'%score)
    print('回家玩吧')

输入成绩59
你的成绩为59
把你妈叫来

pass：空操作，什么也不做。不光条件语句，所有需要的地方都可以使用

score=eval(input('输入年龄：'))
if score<=60:
    pass
elif score<=70:
    print('老年卡')
else:
    print('夕阳红卡')

输入年龄：70
老年卡

循环语句：遍历：每个元素访问且只访问一次

for循环

l=['python',(1,3),'java']#定义列表
for i in l:#i遍历列表
    print(i)

python
(1, 3)
java

dictionary={'one':1,'two':2,'three':3}#定义字典
for i in dictionary:#i遍历字典的键
    print('%s is %d'%(i,dictionary[i]))

one is 1
two is 2
three is 3

遍历一个数列中所有数字，range函数生成一个可迭代对象

print(list(range(1,9,3)))#1~8步长为3
print(list(range(1,9)))#1~8步长为1
print(list(range(9)))#0~9步长为1
print(set(range(1,9)))
print(range(1,9,2))#所以使用range函数时要将该迭代对象转为列表.集合

[1, 4, 7]
[1, 2, 3, 4, 5, 6, 7, 8]
[0, 1, 2, 3, 4, 5, 6, 7, 8]
{1, 2, 3, 4, 5, 6, 7, 8}
range(1, 9, 2)

sum,i=0,list(range(1,100))#1+…+99
for k in i:
    sum+=k
print(sum)#k遍历完列表i，输出

sum,i=0,list(range(1,100))
for k in i:
    sum+=k
    print(sum,end=' ')#k每访问一个列表i中元素，都输出一个sum

1 3 6 10 15 21 28 36 45 55 66 78 91 105 120 136 153 171 190 210 231 253 276 300 325 351 378 406 435 465 496 528 561 595 630 666 703 741 780 820 861 903 946 990 1035 1081 1128 1176 1225 1275 1326 1378 1431 1485 1540 1596 1653 1711 1770 1830 1891 1953 2016 2080 2145 2211 2278 2346 2415 2485 2556 2628 2701 2775 2850 2926 3003 3081 3160 3240 3321 3403 3486 3570 3655 3741 3828 3916 4005 4095 4186 4278 4371 4465 4560 4656 4753 4851 4950

sum,b=0,list(range(eval(input('输入n+1：'))))#1+…+n
for i in b:
    sum+=i
print(sum)

输入n+1：51
1275

sum,n=0,eval(input('输入n：'))#1+…+n
for i in list(range(1,n+1)):
    sum+=i
print(sum)#出了循环再输出

输入n：50
1275

sum,n=0,eval(input('输入n：'))#1到n的奇数和
for i in list(range(1,n+1,2)):
    sum+=i
print(sum)

输入n：50
625

while循环

sum,n,i=0,eval(input('输入n：')),0#1+…+n
while i<=n:
    sum+=i
    i+=1
print(sum)#若i>n，则跳出循环，输出

输入n：50
1275

sum,n,i=0,eval(input('输入n：')),1#1到n所有奇数之和
while i<=n:
    sum+=i
    i+=2
print(sum)

输入n：50
625

sum,n=0,eval(input("输入n："))#1到n所有奇数之和
for i in list(range(1,n+1,2)):
    while i<=n:
        sum+=i
        break
print(sum)

输入n：50
625

索引，len函数，访问元素数量，enumerate函数，访问元素索引与值

l,k=list([1,3.4,'python']),0
s=range(len(l))
for k in s:#k遍历数列s的长度
    print(k,l[k])

0 1
1 3.4
2 python

l=list([1,3.4,'app'])
for k,v in enumerate(l):#默认访问的第一个元素索引为0
    print(k,v)

0 1
1 3.4
2 app

l=list([1,3.4,'app'])
for k,v in enumerate(l,11):#访问的第一个元素索引为11
    print(k,v)

11 1
12 3.4
13 app

break，continue，else

l,sum=eval(input('输入n：')),0#1…n之间7的倍数的和
for i in list(range(1,l+1)):#i遍历1…l
    while i>=7:#i<7的i一定不是7的倍数，所以若i>=7
        if i%7==0:#如果i是7的倍数
            sum+=i#加进来
            break#跳出while循环走for，i遍历下一个元素
        else:#若i不是7的倍数
            break#跳出while循环走for，i遍历下一个元素
print(sum)#i遍历完所有元素输出

输入n：44
147

#输出1-100的素数（素数是仅仅能够被1和自身整除的自然数。）
k=101
for i in range(3,k,1):
    for j in range(2,i):
        if i % j==0:
            break#跳出j的遍历，i继续遍历
    else:#j遍历完所有，都没有i是j的倍数的情况，即没有执行break
        print(i,end=' ')#end=' '是按行写，每个输出空几格的意思

3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

#1~100的素数,对于每个数，考虑其开根号取整作为除数，判断每个数是否不整除每个小于开根号取整，是则素数
for n in range(2,101):#n遍历2-100
    m=int(n**0.5)#m取值根号n取整
    i=2
    while i<=m:#若i小于等于m
        if n%i==0:#若n是i的倍数，不是素数
            break#跳出while循环，走for，n开始遍历下一个元素
        else:
            i+=1#若n不是i的倍数，i+1，循环while
    if i>m:#若n一直不是i<=m的倍数
        print(n,end=' ')#输出n

2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

#3的倍数的整数求和
sum=0
while True:#永真
    n=eval(input('请输入一个整数（输入0程序结束）：'))
    if n==0:#若n为0
        break#跳出while，走第十行，输出0，结束程序
    if n%3!=0:#若n不是3的倍数，不加，即重新输入
        continue#跳出此次，即不走第9行，返回第三行while循环
    sum+=n#若n不为0且是3的倍数，则加起来
print(sum)#输入0，走了第六行的break跳出循环，输出当前的和，结束程序

请输入一个整数（输入0程序结束）：1
请输入一个整数（输入0程序结束）：2
请输入一个整数（输入0程序结束）：3
请输入一个整数（输入0程序结束）：4
请输入一个整数（输入0程序结束）：5
请输入一个整数（输入0程序结束）：6
请输入一个整数（输入0程序结束）：7
请输入一个整数（输入0程序结束）：8
请输入一个整数（输入0程序结束）：9
请输入一个整数（输入0程序结束）：0
18

#素数判断
n=eval(input('请输入大于1的整数：'))
m=int(n**0.5)#m取n的开根号取整
for i in range(2,m+1):
    if n%i==0:#若n是i的倍数，则不是素数
        break#跳出循环，结束程序
else:#i遍历完2到n的开根号取整，n都不是其倍数，则n是素数
    print('%d是素数'%n)#输出

请输入大于1的整数：11
11是素数

#输入素数判断素数
while True:
    n=eval(input('请输入正整数：'))
    if n==1:#若输入1
        break#结束程序
    else:
        m=int(n**0.5)#m取n的开根号取整
        for i in range(2,m+1):
            if n%i==0:#若n是i的倍数，则不是素数
                break#跳出循环，结束程序
        else:#i遍历完2到n的开根号取整，n都不是其倍数，则n是素数
            print('%d是素数'%n)#输出

请输入正整数：32
请输入正整数：6
请输入正整数：3
3是素数
请输入正整数：78
请输入正整数：47
47是素数
请输入正整数：1

王来钱儿

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录