Python-基本语法

input函数
name=input("请输入你的名字：")     #回车后可以输入名字
print(name)   #回车后显示刚刚输入的名字

eval函数：计算字符串表达式返回结果
print函数：输出

r=eval("3+8") 
print(r)   #返回11

>>> r=eval(input("请输入表达式："))
请输入表达式：3+6
>>> print(r)
9

同时定义多个变量
name,age="张三",18

字符串定义
s1,s2,s3="你好",'Hello',"2023"
字符串转整数 int函数-不进行运算
int(s3)  #输出2023
int('16') #输出16
字符串转浮点数 float函数
float('35') #返回35.0
float("35.5") #返回35.5

\ 续行符
\\  反斜杠符/
\' 单引号
\" 双引号
\n 换行
\r 回车
\t 制表符
>>> s='It\'s a book!'
>>> print(s)
It's a book!

>>> print(\
... "你\
... 好！\
... ")
你好！

子串截取[]
下标索引：从前往后数0,1,2...；从后往前数-1,-2,-3...
s[beg:end]  保留s字符串中从beg到end-1位置上的字符串
s[:] 截取所有字符
s[idx] 截取单个字符
>>> s='Hello,world!'
>>> print(s[1:5])
ello
>>> print(s[-2])
d

定义列表 ls=[1,3.14,'test',(3+4j),True,[3,6,9],3]
截取列表的规则同字符串截取
ls[beg:end]  保留ls中从beg到end-1位置上的元素
ls[:] 截取所有元素
ls[idx] 截取单个元素，获取元素本身的类型

列表可修改，字符串不可修改
ls[beg:end]=b #b只能是一个列表
ls[idx]=a #a可以是数值/列表
例如：
ls=[1,3.14,'test',(3+4j),True,[3,6,9],3]
ls[1:3]=[666] 
print(ls)=[1,666,(3+4j),True,[3,6,9],3]

typle元组，与列表类似 ，各元素间用逗号隔开
区别在于用()包含各个元素，且元组不能修改。
元组的元素截取索引规则同列表
>>> t=(13,5.5,'test',True,[1,2,3],())
>>> print(t[1:3])
(5.5, 'test')
>>> print(t[0])  #单一元素访问，获取元素本身的类型
13
>>> print(t[:1]) #元素索引，保留元组类型
(13,)
>>> print(t[-3:-1])
(True, [1, 2, 3])

总结：字符串、列表、元组的元素按下表排列，可通过下表直接访问，这样的数据类型统称为序列。字符串和元组的元素不能修改，列表的元素可以修改。

set集合 {元素1,元素2,...} 
创建集合可以用大括号也可以使用set函数 set([iterable])  interable表示可迭代对象，可以使字符串、列表、元组
若要创建空集合，只能使用set()；{}用于创建空字典。
>>> a={3,2.5,'test',3+4j,True,5.3,2.5}
>>> print(a)
{'test', 2.5, 3, True, 5.3, (3+4j)}
>>> b=set("hello")
>>> print(b)
{'e', 'h', 'o', 'l'}
>>> c=(13,5.5,'test',True,(),'test')
>>> print(set(c))
{'test', True, 5.5, 13, ()}

Dictionary字典 无序的对象集合，字典是一种映射类型，每个元素有一个键(key):值(value)对
创建字典
a={}
b=dict()

>>> a={'one':1,'two':2,'three':3}
>>> b=dict(one=1,two=2,three=3)   #表达式定义
>>> c=dict(zip(['one','two','three'],[1,2,3]))   #zip函数
>>> d=dict([('one',1),('two',2),('three',3)])    #元组的列表
>>> e=dict({'one':1,'two':2,'three':3})     
>>> e=dict(a)      #e定义已有字典
{'one': 1, 'two': 2, 'three': 3}   #创建的字典输出结果都一样的

>>> r=list(zip(['one','two','three'],[1,2,3]))  #将zip函数返回的对象转换成列表
>>> print(r)
[('one', 1), ('two', 2), ('three', 3)]

访问字典的元素
不能通过下标方式访问，通过键（key）访问。
>>> info={'name':'张三','age':18,'score':{'python':95,'math':82}}
>>> print(info['name'])
张三
>>> print(info['score'])
{'python': 95, 'math': 82}
>>> print(info['score']['python'])
95

占位运算符
%d 有符号整型十进制数，%5d 占5个字符，%05d 不足5位前补0,
%f或%F 有符号浮点型十进制数，%.2f 保留两位小数 ，%08.2f 该浮点数占8位且保留两位小数（小数点也算一位）
%s 字符串，%5s 占5个字符

>>> s1='%s上次数学成绩%d，本次成绩%d，成绩提高%f'%('小明',85,90,5/85)
>>> print(s1)
小明上次数学成绩85，本次成绩90，成绩提高0.058824
>>> s2='%5s上次数学成绩%5d，本次成绩%5d，成绩提高%.2f'%('小明',85,90,5/80)
>>> print(s2)
   小明上次数学成绩   85，本次成绩   90，成绩提高0.06
>>> s3='%5s上次数学成绩%05d，本次成绩%05d，成绩提高%08.2f'%('小明',85,90,5/80)
>>> print(s3)
   小明上次数学成绩00085，本次成绩00090，成绩提高00000.06

想要输出百分号%，需要写成%%
>>> print("合格率为%.2f%%"%(80/90))
合格率为0.89%

算数运算符
+（加）x+y
-（减）x-y
*（乘）x*y
/（除）x/y
//（整除）x/y取整数部分
%（取余）x/y取余数
-（负号）-x
+（正号）+y
**（乘方）x**y x的y次幂

赋值运算符
=     y=x
+=  y+=x   y=y+x

比较运算符
==  y==x
!=   y!=x
>    y>x
<    y<x
>=   y>=x
<=   y<=x

比较运算返回布尔值False/True
>>> x,y=25,27
>>> print(x==y)
False
>>> print(x<y)
True

逻辑运算符
and  x and y  x和y都为真，返回真；否则返回假
or    x or y     x和y都为假，返回假；否则返回真
not   not x     x为真，返回假；x为假，返回真
>>> x,y=2,5
>>> print(not(x>0 and y<x))
True

位运算符，针对二进制数进行逐位运算
&   按位与     y&x  对应位都为1，结果则为1，否则取0
|     按位或     y|x    对应位都为0，结果则为0，否则取1
^   按位异或  y^x  对应位不同，结果则为1，否则取0
<<左移位     y<<i 将y左移i位
>>右移位     y>>i 将y右移i位
~   按位取反 ~x    

>>> x,y=2,6
>>> print(y&x)
2
>>> print(y>>x)
1

身份运算符
is    x is y  如果x和y对应相同的存储单元，则返回True，否则返回False
not is    x not is y  如果x和y不对应相同的存储单元，则返回True，否则返回False

输入和输出数据都是存放在内存中，内存中的一个存储单元存放一个字节，每个存储单元都一个唯一的编号，即内存地址。一个数据通常占用内存中连续多个存储单元，起始存储单元的地址称为该数据的内存首地址，可以用id函数查看数据的内存首地址。
x is y 等价于 id(x)==id(y)
x not is y 等价于 id(x)!=id(y)

>>> x,y="你好","你好"
>>> print(x is y)
False
>>> y=x
>>> print(x is y)
True

成员运算符  一个可迭代对象（序列、集合、字典）中是否包含某元素
in    x in y  如果x是可迭代对象y的一个元素，则返回True，否则返回False
not in   x not in y 如果x不是可迭代对象y的一个元素，则返回True，否则返回False

>>> x,y='e','hello'  #字符串
>>> print(x in y)
True
>>> x,y=15,['hello','15',(1,2,3)]   #数组，x是整型，'15'是字符串
>>> print(x in y)
False
>>> y=['hello',15,(1,2,3)]  
>>> print(x in y)
True
>>> x,y=1,(1,2,3)  #元组
>>> print(x in y)
True
>>> x,y=2,{2,4,6}  #集合
>>> print(x in y)
True
>>> x,y="one",{"one":1,"two":2,"three":3}  #字典
成员运算符判断一个数据是否是字典中的元素，实际上是判断该数据是否为字典中的某个键，不是键对应的值。
>>> print(x in y)
True
>>> print(2 in y)  
False

序列运算符  序列（字符串、列表、元组）
+ 拼接 x+y  将序列x和序列y的元素进行连接，生成新的序列
*  重复 x*n  将序列x中的元素重复n次，生成一个新的序列
>>> x,y="Hello,","world！"
>>> print(x+y)
Hello,world！
>>> x,y=[2,4],[6,'abc',True]
>>> print(x+y)
[2, 4, 6, 'abc', True]
>>> x_3=x*3
>>> print(x_3)
[2, 4, 2, 4, 2, 4]

条件语句
if 条件1:
  语句1
elif 条件2:
  语句2
...
elif 条件n:
  语句n
else:
  语句n+1

score=eval(input("请输入成绩："))
if score<60:
    print("本次成绩为%d分，要加油了。"%score)
    print("不及格")
elif score<70:
    print("本次成绩为%d分，要努力了。"%score)
    print("及格")
elif score<90:
    print("本次成绩为%d分，继续保持。"%score)
    print("良好")
else:
    print("本次成绩为%d分，不许骄傲。"%score)
    print("优秀")

pass 空操作，占位作用，执行时什么都不做

score=eval(input("请输入成绩："))
if score<60:
    pass
else:
    print("成绩合格")

循环语句

for循环，用于遍历可迭代对象中的每一个元素，并对当前访问元素做数据处理，语法如下：
for 变量名 in 可迭代对象:
  语句序列

ls=[2,4,6]
for k in ls:
    n=k+1
    print(n)

输出结果：
3
5
7

d={"Python":86,"C++":80,"Java":78}
for k in d:
    print("%s的成绩为%d分"%(k,d[k]))

结果如下：
Python的成绩为86分
C++的成绩为80分
Java的成绩为78分

range函数  创建整数序列
range([beg,]end[,step])

n=eval(input("请输入一个正整数："))
sum=0
for i in range(1,n+1): 
    sum=sum+i
print("1到%d间的所有整数的求和结果：%d"%(n,sum))

结果如下：
请输入一个正整数：3
1到3间的所有整数的求和结果：6

n=eval(input("请输入一个正整数："))
sum=0
for i in range(2,n+1,2):
    sum=sum+i
print("1到%d间的所有偶数的求和结果：%d"%(n,sum))

结果如下：
请输入一个正整数：4
1到4间的所有偶数的求和结果：6

n="Hello,world!"
for i in range(2,9):     #range函数在该语句中相当于元素索引的可迭代对象，i相当于索引
    print(n[i])

结果如下：
l
l
o
,
w
o
r

while循环
while 循环条件:  #满足循环条件则执行下列语句
  语句序列

n=eval(input("请输入一个正整数："))
sum,i=0,1
while i<=n:
    sum=sum+i
    i=i+1
print("1到%d间所有整数的求和结果：%d"%(n,sum))

结果如下：
请输入一个正整数：10
1到10间所有整数的求和结果：55

len函数 获取可迭代对象中的元素数量

ls=["Python","C++","Java"]
for k in range(len(ls)):
    print("%d--%s"%(k,ls[k]))

结果如下：
0--Python
1--C++
2--Java

enumerate函数，返回的索引序列对象，同时获得每个元素的索引和值
enumerate(可迭代对象[,n])  #n为索引起始值，默认为0

ls=["Python","C++","Java"]
print(list(enumerate(ls)))


结果如下：
[(0, 'Python'), (1, 'C++'), (2, 'Java')]

ls=["Python","C++","Java"]
print(list(enumerate(ls,1)))


结果如下：
[(1, 'Python'), (2, 'C++'), (3, 'Java')]

ls=["Python","C++","Java"]
for k,v in enumerate(ls):
    print(k,v)
print("---------")
for k,v in enumerate(ls,1):
    print(k,v)

结果如下：
0 Python
1 C++
2 Java
---------
1 Python
2 C++
3 Java

break用于跳出for循环或while循环。多重循环情况，跳出最近的那个循环。

for m in range(2,101):
    a=1
    for n in range(2,m):
        if m%n==0:
            a=0
            break #m能被n整除，说明m一定不是质数，退出循环，判断下一个数
    if a==1:
        print(m,end=',')

结果如下：
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,

end的用法 是print()中的一个参数，一般用于循环语句中，将结果输出到同一行，或者在输出的末尾添加不同的字符

continue用于结束本次循环并开始下一次循环。对于多重循环情况，作用于最近的那重循环。

else 在for循环和while循环后面可以跟着else分支，当for循环已经遍历完列表中所有元素或while循环的条件为False时，执行else分支.

for m in range(2,101):
    n=2
    while n<m:
        if m%n==0:
            break #m能被n整除，说明m一定不是质数，退出while循环，判断下一个数
        else:
            n=n+1
    else: #while循环的条件为False时，执行else分支.break退出循环时不执行
        print(m,end=' ')


结果如下：
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