初识基本数据类型，与用户交互，格式化输出，基本运算符

初识基本数据类型

• 什么是数据类型?

在现实生活中存储数据的方式和表现形式有很多。eg：文本文件 表格文件 视频文件 音频文件 图片文件...

在IT世界里数据的存储方式和表现形式也是千变万化的

数据类型是用来记录事物状态的，而事物的状态是不断变化的(如:一个人年龄的增长（操作int类型），单个人名的修改（操作str类型），学生列表中增加学生（操作list类型）等)，这意味着我们在开发程序时需要频繁对数据进行操作，为了提升我们的开发效率， python针对这些常用的操作，为每一种数据类型内置了一系列方法。本章的主题就是带大家详细了解下它们，以及每种数据类型的详细定义、类型转换。

数据类型之整型int

• 作用：用来记录年龄、个数、号码、等整数相关的状态

  age = 18
  
  print(type(age)  # <class 'int'>

   

数据类型之浮点型float

• 作用：用来记录身高、体重、薪资等小数相关的状态

  weight = 80.3
  
  print(type(weight))  # <class 'float'>
  数据类型之字符串类型str

  数据类型之字符串类型str

• 作用：用来记录姓名，性别，住址，等描述性质的状态

  # 方式一：单引号
  name = 'geng'
  
  # 方式二：双引号
  name1 = "geng"
  
  # 方式三：三个单引号(赋值皆为字符串，否则为注释)
  name2 = '''geng'''
  
  # 方式四：三个单引号(赋值皆为字符串，否则为注释)
  name3 = """geng"""
  
  # 方式五：为了防止文本内需要用到引号，应采取外双内单的形式
  name4 = "'大佬说'：今天天气很好"
  
  print(type(msg4))  # <class 'str'>
  
  print(name4)  # '大佬说'：今天天气很好
  
  gender = "male"
  
  country = "china"
  
  name="mike"

   

数据类型之列表类型list

• [ ] 内用逗号分隔开多个任意类型的元素

• 作用：专门用来记录多个同种属性的值，并且存取都十分方便

  #     0    1         2           3
  l = [111, 3.3, [666, 777, 88], "abc"]
  
  print(type(l))  # <class 'list'>
  
  # 索引取值(从0开始的连续数字)
  print(l[0])  # 111
  
  print(l[1])  # 3.3
  
  print(l[2])  # [666, 777, 88]
  
  print(l[-1])  # "abc"
  
  print(l[2][0])  666
  
  hobbies = ["read", "music", "movie", "play"]
  
  print(hobbies[1])  # "music"

   

数据类型之字典类型dict

•  { } 用逗号分隔开多个元素，每一个元素的组成都是key:value，键值对的形式，其中value可以是任意类型，而key通常是字符串类型

• 作用：按照key存放多个值，key反映的value的属性，能够更加精准的存储数据

  d = {"k1": 111, "k2": 1.3, "k3": "abcdef", "k4": [111, 222, 333], "k5": {"a": 1, "b": 2}}
  
  print(type(d))  # <class 'dict'>
  
  print(d["k3"])  # abcdef
  
  print(d["k4"][1]) # 222
  
  print(d["k5"]["a"]) # 1
  
  # 案例：mike的个人信息
  name = "mike"
  age = 18
  gender = "male"
  level = 19
  
  # 用列表记录个人信息非常的不清晰
  #         0     1     2    3
  info = ["mike", 18, "male", 19]
  print(info[1])  # 18
  
  # 字典无法使用索引取值，需要借助于Key
  info = {
          "name": "mike",
          "age": 18,
          "gender": "male",
          "level": 19
          }
  print(info["age"])  # 18
  
  # 案例：存放多个同学的信息
  students = [
      {"name": "mike", 'age': 18, "gender": "male"},
      {"name": "tom", 'age': 19, "gender": "male"},
      {"name": "lili", 'age': 28, "gender": "female"},
  ]
  
  print(students[1]['age']) # 19

   

数据类型之元组tuple

• ( )内用逗号隔开多个任意类型的元素，元素不支持修改，元组相当于不可变的列表

• 作用：用于记录多个固定不允许修改的值，单纯用于取

  t = (11, 3.1, "jason", [11, 22, 33])
  
  print(type(t))  # <class 'tuple'>
  
  # 如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元祖
  t = (11,)

   

数据类型之集合set

• 作用：主要用于去重和关系运算

  {}内逗号隔开多个元素,元素不是K:V键值对，集合具备以下三个特点
      1）集合类元素必须是不可变类型
         2）集合类元素不能重复
             3）集合内元素无序
  
  s = {1, 2, 3, 4}
  print(type(s))  # <class 'set'>

   

数据类型之布尔类型bool

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

  # 布尔值只有两种状态
  x = True
  y = False
  
  print(type(x))  # <class 'bool'>
  
  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 <class 'str'>

# 案例：
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支持的算术运算符与数学上计算的符号使用是一致的

算数运算符	描述
+	加，两个对象相加
-	减，两个对象相减
*	乘，两个对象相乘
/	除，相除后得到的返回值会保留整数与小数部分
//	取整除，相除后得到的返回值只保留整数部分
%	取余，相除后只返回余数
**	幂，取一个数的n次方

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

比较运算符	描述
==	等于，两个对象相等返回True，否则返回False
!=	感叹号等于，两个对象相等返回False，否则返回True
>	大于
>=	大于等于
<	小于
<=	小于等于

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