一、python的输入input函数（）

input函数作用

接收来自用户的输入

input函数返回值类型（也就是结果是什么类型）

输入值的类型位str

input函数值的存储

使用=对输入的值进行存储

input函数的使用

293BA31A78FD7A64141291CE30311CFE.png

  • input括号中的问句是一个提问—-也就是在程序输入前程序给我们的一个提示语，我们根据提示与输入一个数据
  • 输入的数据会存储到变量中
    1. present=input('大圣想要什么礼物？')  #输入提问，将输入的结果存储到present变量中
    2. print(present,type(present))     #输出输入的内容，在输出其输入内容的字符串类型
    2345截图20210206095846.png

    练习

    从键盘中输入两个整数，计算两个整数的和
    1. a=input('请输入一个加数')
    2. b=input('请输入另外一个加数')
    3. print(a+b)      #将两个加数加到一起输出，报错，说明两个加数并没有进行整数相加的运算而是起了一个连接作用
    2345截图20210206101552.png
    报错
    两个加数并没有进行整数相加的运算而是起了一个连接作用
    分析
    input函数的结果是字符串类型，所以不能相加，加号起到了连接作用
    解决办法
    通过类型转换把str类型通过int()函数转换成int类型、
    方法一
    1. a=input('请输入一个加数')
    2. a=int(a)   #将转换之后的结果存储到a中
    3. b=input('请输入另外一个加数')
    4. b=int(b)   #将转换之后的结果存储到b中
    5. print(type(a),type(b))   #input函数的结果是字符串类型，所以不能相加
    6. print(a+b)      #将两个加数加到一起输出，报错，说明两个加数并没有进行整数相加的运算而是起了一个连接作用
    2345截图20210206102504.png
    方法二
    1. #从键盘中输入两个整数，计算两个整数的和
    2. a=input('请输入一个加数')
    3. b=input('请输入另一一个加数')
    4. print(type(a),type(b))
    5. print(int(a)+int(b))
    方法三
    1. a=int(input('请输入一个加数'))   #输入完结果就直接转换成int类型
    2. b=int(input('请输入另外一个加数'))   #输入完结果就直接转换成int类型
    3. print(type(a),type(b))   #input函数的结果是字符串类型，所以不能相加
    4. print(a+b)      #将两个加数加到一起输出，报错，说明两个加数并没有进行整数相加的运算而是起了一个连接作用


二、Python中的运算符

算术运算符

标准算术运算符

加（+）减（-）乘（*）除（/）以及整除（//）

  1. #标准运算符
  2. print(1+1)   # 加法运算
  3. print(1-1)   # 减法运算
  4. print(2*4)   # 乘法运算
  5. print(11/2)   # 除法运算
  6. print(11//2) # 整除运算

取余运算符

%

  1. print(11%2)   # 取余运算

幂运算符

**

  1. print(2**2)   #表示2的2次方 幂运算
  2. print(2**3)   #表示3的3次方 幂运算

特殊情况

678D6E89686638AC0F0EC1565607CE26.png

一正一负情况下进行整除或者取余

整除(一正一负的整数公式，向下取整)

  1. print(9/4)
  2. print(9//-4)     #一正一负的整数公式，向下取整
  3. print(-9//4)

取余**(在两者为一正一负的情况下这样计算：余数=被除数-除数*商)**

  1. print(9%4)       #二者都是同好的话就正常计算
  2. print(9%-4)      #被除数-除数*商  9%-4 ------ 9-(-4)*(-3)
  3. print(-9%4)      #被除数-除数*商  -9%4 ------ -9-(4)*(-3)

赋值运算符

执行顺序

从右到左（右—->左）

  1. i=4+3
  2. print(i)      #4+3得出计算后通过赋值运算符存放在b中

支持链式赋值

a=b=c=20

  1. a=b=c=20
  2. print('标识',id(a))
  3. print('标识',id(b))
  4. print('标识',id(c))

支持参数赋值

+=、-=、*=、/=、//=、%=

  1. print('-------------支持参数赋值-------------')
  2. a=20
  3. a+=30            #相当于a=a+30
  4. a-=10            #相当于a=a-10
  5. print(a)
  6. a*=2             #相当于a=a*2
  7. print(a,type(a))
  8. a/=3             #相当于a=a/3
  9. print(a,type(a))
  10. a//=2            #相当于a=a//2   float类型的a与int类型2进行计算得到的是float类型
  11. print(a,type(a))
  12. a%=3
  13. print(a,type(a))

支持系列解包赋值

a,b,c=20,30,40

  1. print('-------------支持系列解包赋值----------------')
  2. a,b,c=20,30,40      #代码中相当于有三个对象，分别有标识、类型和值。左变的变量和右边值的个数要相同，输出时位置和顺序不能错
  3. print(a,b,c)        #a<----20,b<----30,c<----40
  4. a,b=20,30,40
  5. print(a,b,c)        #左变的变量和右边值的个数要相同,不然会报错

注意

  • 左变的变量和右边值的个数要相同,
  • 输出时位置和顺序不能错

解包赋值的好处

  1. print('-----------解包赋值的好处-----------')
  2. a,b=10,20
  3. print('交换之前:',a,b)
  4. #交换
  5. a,b=b,a   #把b的值赋给a，把a的值赋给b
  6. print('交换之后:',a,b)

2345截图20210206185433.png

比较运算符

对变量或表达式的结果进行大小或真假等比较

常见比较运算符

（1）>, < , >= , <= ,!=（比较运算符的结果为bool布尔类型—true或者false）

  1. a,b=10,20            #解包赋值
  2. print('a>b吗？',a>b)    #False   
  3. print('a<b吗？',a<b)    #True
  4. print('a>=b吗？',a>=b)  #True

（2）== !=

对象value的比值

  1. print('a==b吗？',a==b)  #False    一个'='号称为赋值运算，'=='成为比较运算符号
  2. print('a!=b',a!=b)     #True      一个变量由三部分组成分别是：标识id、类型type和值value

注意：
一个’=’号称为赋值运算，’==’成为比较运算符号

（3）一个变量由三部分组成，标识，类型，值

==比较的是标识还是值？ 比较的是值
比较对象的标识使用 is

（4）is , is not

对象id的比较
==比较的是标识还是值？ 比较的是值
比较对象的标识使用 is

  1. lst1=[11,22,33,44]
  2. lst2=[11,22,33,44]
  3. print(lst1==lst2)       #比较的是value----->true
  4. print(lst1 is lst2 )    #比较的是id-------->false
  5. print(id(lst1))
  6. print(id(lst2))
  7. print(a is not b)       #False  a的id与b的id是不相同的
  8. print(lst1 is not lst2) #true  lst1与lst2的id是不同的

布尔运算付符

布尔运算符—— and，or，not，in ，not in6AC90B9321B3A30E0FD475597565FB2A.png

（1）and———->并且

  1. #布尔值运算    and, or , not, i n ,  not in
  2. print('------------并且----------------')
  3. a,b=1,2          #解包赋值
  4. print(a==1,b==2)      #True    a等于1并且b等于2---
  5. print(a==1 and b<2)   #False   a等于1并且b小于2
  6. print(a!=1 and b==2)  #False   a不等于1并且b等于2
  7. print(a!=1 and b!=2)  #False   a不等于1并且b不等于2

当两个运算数都为True时，运算结果才为True

（2）or————->或者

  1. print('--------------or或者-------------')
  2. a,b=1,2          #解包赋值
  3. print(a==1 or b==2)     #True    a等于1或者b等于1
  4. print(a==1 or b<2)      #True    a等于1或者b小于1
  5. print(a!=1 or b==2)     #True    a不等于1或者b等于1
  6. print(a!=1 or b!=2)     #False   a不等于1或者b不等于2

只有一个运算结果为True，运算结果就为True

（3）not（非）—————>对bool类型操作数取反

  1. print('-------------not对bool类型操作数取反----------')
  2. f=True
  3. f2=False
  4. print(not f)       #对f取反
  5. print(not f2)      #对f2取反

如果运算数为True，运算结果为False
如果运算结果为False，运算结果为True

(4) in and not in —————>在和不在

  1. s='helloworld'
  2. print('w' in s)       #true
  3. print('c' in s)       #false
  4. print('h' not in s)   #False
  5. print('p' not in s)   #True

位运算符

将数据转成二进制进行计算

一、按位与& ——————>

（1）打开calc计算器，找到十进制4和8对应的二级制数，分别为100，1000
9C7536A8E8A95A477DFFAD691FF23CA6.png
注意：
对应数位都是1，结果数位才是1，否则为0

  1. print(4 & 8)     #按位与& 同时为1结果为1

二、按位或I ——————>

打开calc计算器，找到十进制4和8对应的二级制数，分别为100，1000。
DDBBD9AA3CB4140FFE5C87A9FBFC25E6.png

  1. print(4 | 8)   #按位或| 同时为0结果为0

注意

对应数位都是0，结果数位才是0，否则为1

三、左移位运算符<< ——————>高位溢出舍弃，低位补0.

1151BF2777FB6242FDCB282EEECEDD81.png

  1. print(4<<1)  #向左移动1位（移动一个位置）

注意：

高位溢出舍弃，低位补0.
左移一位相当于乘于二

四、右移位运算符>> ——————>低位溢出舍弃，高位补0

E12B61F1AD5B22FA199F35BE0DF308B6.png

  1. print(4>>1)  #向右移动1位（移动一个位置）

注意

低位溢出舍弃，高位补0
向右移动1位（移动一个位置）相当于除于二

三、运算符的优先级

算术运算—->位运算———>比较运算——>布尔运算——->赋值远算

算术运算

‘*’———>’ ‘————>’ / ‘————-> ‘// ‘————->’ % ‘————>’+’ ————>’ -‘

位运算

‘<< ‘———> ‘ >>’ ————> ‘& ‘————> ‘| ‘

比较运算符

‘>’——> ‘<’ ———> ‘>=’ ———-> ‘<=’ ————> ‘==’ ————-> ‘!=’

布尔运算符

‘and’ ———> ‘or’

赋值运算符

‘=’