初识基本数据类型

• 作用：用来记录真假两种状态

  # 布尔值只有两种状态
  x = True
  y = False
  print(type(x)) #
  print(10 == 10y # True
  print(10 > 3) # True
  
  name = "tom"
  print(name == "mike") # False

   

  
  

与用户交互

获取用户输入

inp_name = input("请输入您的用户名：")
'''
将input获取到的用户输入绑定给变量名inp_name
input获取到的用户输入全部都会转成字符串
'''
print(inp_name,type(inp_name)) # geng
# 案例：
inp_name = input("请输入您的用户名：") # inp_name = "geng"

inp_pwd = input("请输入您的密码：") # inp_pwd = "123"

格式化输出

print() # 输出
'''
1.括号可以使用逗号隔开多个元素一起打印
2.自带end参数 可以控制打印的排版
'''
print("1111",end='')
print("2222")
# 输出结果：11112222
# 将字符串中某些内容替换掉再输出就是格式化输出
"""
1.先使用占位符占位 %s
2.再使用%按照位置一一替换
"""
# 示例：
name = input("your name: ")
age = input("your age: ")
print("my name is %s my age is %s" % (name,age))
# 输出结果：my name is geng my age is 18
print("my name is %s my age is %d" % ("jack",19))
# 输出结果：my name is jack my age is 19
# %d 只能接收数字（了解）
print("my name is %s my age is %d" % ("jack","19")) # 报错
print("my name is %s my age is %s" % ("jack",[1,2,3]))
# 输出结果：my name is jack my age is [1, 2, 3]

基本运算符

1、算术运算符

python支持的算术运算符与数学上计算的符号使用是一致的

salary = 3.3
res = salary * 12
print(10 + 1) # 11
print(10 / 3) # 3.3333333333333335
print(10 // 3) # 3
print(10 % 3) # 1000
print(10 ** 3) # 1000，10的3次方
print(10 + 3.1)
print(10 % 3)
# ps:整型和浮点型可以混着计算

2、比较运算符

比较运算用来对两个值进行比较，返回的是布尔值True或False

x = 10 # int
y = 10.0 # float
# 整型和浮点型比较
print(x == y) # True

m = 10 # int
n = "10" # str
# 仅限同类型
print(m == n) # False
# == 不限类型
print(10 == [1,2,3]) # False
print(10 + [1,2,3]) # 报错
print(10 == [1,2,3]) # False
print(10 != [1,2,3]) # True
print(10 > 3.1) # True
print(10 >= 3.1) # True
print(10 <= 3.1) # False
print(10 <3.1) # False

3、赋值运算符

python语法中除了有=号这种简单的赋值运算外，还支持增量赋值、链式赋值、交叉赋值、

解压赋值，这些赋值运算符存在的意义都是为了让我们的代码看起来更加精简

• 增量赋值

• 
  
  
  

  • age = 18 # 简单赋值运算
    
    age += 10 # age = age + 10 加法赋值运算
    print(age) # 28
    
    age *= 10 # 乘法赋值运算
    print(age) # 180
    
    age %= 3 # age = age % 3 取余赋值运算
    print(age） # 0
    链式赋值
    如果我们想把同一个值同时赋值给多个变量名，可以这么做
    x = 10
    y = x
    z = y
    # 链式赋值指的是可以用一行代码搞定这件事
    x = y = z = 10
    print(x, y, z)
    print(id(x), id(y), id(z))
    交叉赋值
    我们定义两个变量m与n，如果我们将m与n的值交换过来
    m = 10
    n = 20
    # 方式一：利用中间变量
    temp = m
    m = n
    n = temp
    print(m, n) # 20 10
    # 方式二：交叉赋值指的是一行代码可以搞定这件事
    m, n = n, m
    print(m, n) # 20 10
    解压赋值
    如果我们想把列表中的多个值取出来一次赋值给多个变量名，可以这么做
    salaries = [11, 22, 33, 44, 55]
    mon1 = salaries[0]
    mon2 = salaries[1]
    mon3 = salaries[2]
    mon4 = salaries[3]
    mon5 = salaries[4]
    # 解压赋值：左右两边个数相等
    mon1, mon2, mon3, mon4, mon5 = salaries
    # 变量名变少了
    mon1, mon2, mon3, mon4 = salaries # 错误
    # 变量名变多了
    mon1, mon2, mon3, mon4, mon5, mon6= salaries # 错误
    # 如果只想取前面的几个值，可以用*_匹配
    mon1, mon2, mon3, *_ = salaries
    print(mon1) # 11
    print(mon2) # 22
    print(mon3) # 33
    print(_) # [44, 55]
    # 取倒数两个值
    *_, last2, last1 = salaries
    print(last1) # 55
    print(last2) # 44
    print(_) # [11, 22, 33]
    # 取前一个以及后两个值
    mon1,*_,last2,last1=salaries
    print(mon1) # 11
    print(last1) # 55
    print(last2) # 44
    # 如果想取中间的值，*加middle
    _,*middle,_=salaries
    print(middle) # [22, 33, 44]
    print(_) # 55

     

    
    
  
  
  
  

4、逻辑运算符

逻辑运算符用于连接多个条件，进行关联判断，会返回布尔值True或False

• not：非，将紧跟其后的那个条件取反，not优先级最高
  print(not 10 > 3)
  # False
  and：与，连接多个条件，且多个条件必须为True，最终结果才为True
  print("jack" == "jack" and 10 > 3) # True
  print("jack" == "Jack" and 10 > 3) # False
  or：或，连接多个条件，有一个条件为True，最终结果就为True
  print("jack" == "jack" or 10 > 3) # Ture
  print("jack" == "Jack" or 10 > 3) # Ture
  优先级：not>and>or
  ① 三者的优先级关系：not>and>or，同一优先级默认从左往右计算。
  3>4 and 4>3 or not 1 == 3 and 'x' == 'x' or 3 >3
  print(3>4 and 4>3 or not 1==3 and 'x' == 'x' or 3 >3)
  (3>4 and 4>3) or (not 1==3 and 'x' == 'x') or 3 >3
  # True
  ② 但是我们在编写的时候应该人为的规定好优先级，其实意义与上面一样
  原理为：
  (1) not的优先级最高，就是把紧跟其后的那个条件结果取反，所以not与紧跟其后的条件不可分割
  (2) 如果语句中全部是用and连接，或者全部用or连接，那么按照从左到右的顺序依次计算即可
  (3) 如果语句中既有and也有or，那么先用括号把and的左右两个条件给括起来，然后再进行运
  print(1 != 1 or 3 > 4 and not "xx" == "jack" or 1 > 10 and 9 > 3 and 1 > 0)
  1 != 1 or (3 > 4 and not "xx" == "jack") or ((1 > 10 and 9 > 3) and 1 > 0)
  # False
  ③ 短路运算：偷懒原则（能少算就尽量少算）
  逻辑运算的结果一旦可以确定，那么就以当前处计算到的值作为最终结果返回
  print(1 > 0 and 1 != 1 and 3 > 2) # False
  print(1 > 0 or 1 != 1 or 3 > 2) # True

   

  
  



• 
  

5、成员运算

• in与not in
  判断某一个个体在不在某个群体内

  
  
  
  

  • in ：某一个对象包含于另一个对象则返回True，字符串，列表，字典，集合，元祖都支持成员运算

    
    
  
  

  • not in 某一个对象没有包含于另外一个对象则返回True

    
    
  
  
  
  

```python
name_list = ['jason', 'kevin', 'tony', 'jackson']
name = input('请输入您要查询的学生姓名>>>:')
# print(name in name_list)
# print(name not in name_list)
# print('j' in 'jason j j j n n')
print('jason' in {'username': 'jason', 'age': 18}) # False
# 字典默认暴露给外界的只有K
print('username' in {'username': 'jason', 'age': 18})
```

6、身份运算

• is与 = =
  判断两个数据的值和内存地址是否相等
  is ：判断左右两个值内存地址（身份id）是否相等
  == ：判断左右两个值是否相等

   

  
  

注意：

（1）如果内存地址（id）相等，意味着 type（类型） 和 value（值）必定相等
x = 1000
y = x
print(x is y)
​ （2）value （值）相等 type（类型）肯定相等，但内存地址（id）不一定相等
C:\Users\oldboy>python3
Python 3.8.6 (tags/v3.8.6:db45529, Sep 23 2020, 15:52:53) [MSC
v.1927 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more
information.
>>> x=1000
>>> y=1000
>>> id(x)x
2577369562032
>>> id(y)
2577369562096
>>>
>>> x is y
False
>>> x == y
True
>>>
补充了解：布尔值分为两大类
1、显式的布尔值：能明确地得到True或False，比如x=True,10 > 3, 10 > 3 and 1==1
3 == 1 and True and 10 > 3
print(3 == 1 and True and 10 > 3) # False
2、隐式的布尔值：所有的数据类型的值都可以当作隐式的布尔值，其中0、None、空对应隐式布尔值为False，其余对应隐式布尔值为True
复制10 and 3 and 4 > 2
print(10 and 3 and 4 > 2) # True
print(10 and 0 and 4 > 2) # 0
print(0 and 2 or 1) # 1