初识基本数据类型

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

什么是数据类型?

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

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

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

数据类型之整型int

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

print(type(age) # 

  2. <a name="d51b812e"></a>
  3. ## 数据类型之浮点型float
  5. -  **作用：用来记录身高、体重、薪资等小数相关的状态**  
  6. ```python
  7. weight = 80.3
  9. print(type(weight))  # <class 'float'>

数据类型之字符串类型str

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

    方式一：单引号

    name = ‘geng’

方式二：双引号

name1 = “geng”

方式三：三个单引号(赋值皆为字符串，否则为注释)

name2 = ‘’’geng’’’

方式四：三个单引号(赋值皆为字符串，否则为注释)

name3 = “””geng”””

方式五：为了防止文本内需要用到引号，应采取外双内单的形式

name4 = “‘大佬说’：今天天气很好”

print(type(msg4)) #

print(name4) # ‘大佬说’：今天天气很好

gender = “male”

country = “china”

name=”mike”

  2. <a name="56376063"></a>
  3. ## 数据类型之列表类型list
  5. -   **[ ] 内用逗号分隔开多个任意类型的元素** 
  6. -  **作用：专门用来记录多个同种属性的值，并且存取都十分方便**  
  7. ```python
  8. #     0    1         2           3
  9. l = [111, 3.3, [666, 777, 88], "abc"]
  11. print(type(l))  # <class 'list'>
  13. # 索引取值(从0开始的连续数字)
  14. print(l[0])  # 111
  16. print(l[1])  # 3.3
  18. print(l[2])  # [666, 777, 88]
  20. print(l[-1])  # "abc"
  22. print(l[2][0])  666
  24. hobbies = ["read", "music", "movie", "play"]
  26. print(hobbies[1])  # "music"

数据类型之字典类型dict

  • { } 用逗号分隔开多个元素，每一个元素的组成都是key:value，键值对的形式，其中value可以是任意类型，而key通常是字符串类型
  • 作用：按照key存放多个值，key反映的value的属性，能够更加精准的存储数据
    ```python d = {“k1”: 111, “k2”: 1.3, “k3”: “abcdef”, “k4”: [111, 222, 333], “k5”: {“a”: 1, “b”: 2}}

print(type(d)) #

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

  2. <a name="1f120f6e"></a>
  3. ## 数据类型之元组tuple
  5. -  **( )内用逗号隔开多个任意类型的元素，元素不支持修改，元组相当于不可变的列表** 
  6. -  **作用：用于记录多个固定不允许修改的值，单纯用于取**  
  7. ```python
  8. t = (11, 3.1, "jason", [11, 22, 33])
  10. print(type(t))  # <class 'tuple'>
  12. # 如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元祖
  13. t = (11,)

数据类型之集合set

  • 作用：主要用于去重和关系运算
    ```python {}内逗号隔开多个元素,元素不是K:V键值对，集合具备以下三个特点 1）集合类元素必须是不可变类型
    1. 2）集合类元素不能重复
    2.     3）集合内元素无序

s = {1, 2, 3, 4} print(type(s)) # 

  2. <a name="6a9b44a9"></a>
  3. ## 数据类型之布尔类型bool
  5. ![](https://gitee.com/gengff/blogimage/raw/master/images/WechatIMG496_gaitubao_351x226.png#id=bnAX9&originHeight=226&originWidth=351&originalType=binary&ratio=1&status=done&style=none)
  7. -  **作用：用来记录真假两种状态**  
  8. ```python
  9. # 布尔值只有两种状态
  10. x = True
  11. y = False
  13. print(type(x))  # <class 'bool'>
  15. print(10 == 10y  # True
  17. print(10 > 3)  # True
  19. name = "tom"
  20. print(name == "mike") # False

与用户交互

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

获取用户输入

  1. inp_name = input("请输入您的用户名：")
  3. '''
  4. 将input获取到的用户输入绑定给变量名inp_name
  5. input获取到的用户输入全部都会转成字符串
  6. '''
  7. print(inp_name,type(inp_name))  # geng <class 'str'>
  9. # 案例：
  10. inp_name = input("请输入您的用户名：")  # inp_name = "geng"
  12. inp_pwd = input("请输入您的密码：")  # inp_pwd = "123"

格式化输出

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

基本运算符

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

1、算术运算符

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

算数运算符 描述
+ 加，两个对象相加
- 减，两个对象相减
* 乘，两个对象相乘
/ 除，相除后得到的返回值会保留整数与小数部分
// 取整除，相除后得到的返回值只保留整数部分
% 取余，相除后只返回余数
** 幂，取一个数的n次方 
  1. salary = 3.3
  2. res = salary * 12
  4. print(10 + 1)  # 11
  6. print(10 / 3)  # 3.3333333333333335
  8. print(10 // 3)  # 3
  10. print(10 % 3)  # 1000
  12. print(10 ** 3)  # 1000，10的3次方
  14. print(10 + 3.1)
  15. print(10 % 3)
  16. # ps:整型和浮点型可以混着计算

2、比较运算符

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

比较运算符 描述
== 等于，两个对象相等返回True，否则返回False
!= 感叹号等于，两个对象相等返回False，否则返回True
> 大于
>= 大于等于
< 小于
<= 小于等于 
  1. x = 10  # int
  2. y = 10.0  # float
  4. # 整型和浮点型比较
  5. print(x == y)  # True
  7. m = 10  # int
  8. n = "10"  # str
  9. # 仅限同类型
  10. print(m == n)  # False
  12. # == 不限类型
  13. print(10 == [1,2,3])  # False
  15. print(10 + [1,2,3])  # 报错
  17. print(10 == [1,2,3])  # False
  19. print(10 != [1,2,3])  # True
  21. print(10 > 3.1)  # True 
  23. print(10 >= 3.1)  # True 
  25. print(10 <= 3.1)  # False
  27. print(10 < 3.1)  # False

3、赋值运算符

python语法中除了有=号这种简单的赋值运算外，还支持增量赋值、链式赋值、交叉赋值、解压赋值，这些赋值运算符存在的意义都是为了让我们的代码看起来更加精简

  • 增量赋值 | 复制运算符 | 描述 | | —- | —- | | = | 简单赋值运算 | | += | 加法赋值运算 | | -= | 减法赋值运算 | | = | 乘法赋值运算 | | /= | 除法赋值运算 | | //= | 取整赋值运算 | | %= | 取余赋值运算 | | = | 幂赋值运算 |
  1. age = 18  # 简单赋值运算
  3. age += 10  # age = age + 10 加法赋值运算
  4. print(age)  # 28
  6. age *= 10  # 乘法赋值运算
  7. print(age)  # 180
  9. age %= 3 # age = age % 3 取余赋值运算
  10. print(age） # 0
  • 链式赋值
    • 如果我们想把同一个值同时赋值给多个变量名，可以这么做
      ```python x = 10 y = x z = y

链式赋值指的是可以用一行代码搞定这件事

x = y = z = 10

print(x, y, z) print(id(x), id(y), id(z))

  2. -  **交叉赋值** 
  3.    -  我们定义两个变量m与n，如果我们将m与n的值交换过来  
  4. ```python
  5. m = 10
  6. n = 20
  8. # 方式一：利用中间变量
  9. temp = m
  10. m = n
  11. n = temp
  12. print(m, n)  # 20 10 
  14. # 方式二：交叉赋值指的是一行代码可以搞定这件事
  15. m, n = n, m
  16. print(m, n)  # 20 10
  • 解压赋值
    • 如果我们想把列表中的多个值取出来一次赋值给多个变量名，可以这么做
      ```python 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

  2. <a name="5cc8627e"></a>
  3. ## 4、逻辑运算符
  5. 逻辑运算符用于连接多个条件，进行关联判断，会返回布尔值True或False<br />   
  7. - **not：非，将紧跟其后的那个条件取反，not优先级最高**
  8. ```python
  9. print(not 10 > 3)
  10. # False
  • and：与，连接多个条件，且多个条件必须为True，最终结果才为True ```python print(“jack” == “jack” and 10 > 3) # True

print(“jack” == “Jack” and 10 > 3) # False

  3. - **or：或，连接多个条件，有一个条件为True，最终结果就为True**
  4. ```python
  5. print("jack" == "jack" or 10 > 3)  # Ture
  7. print("jack" == "Jack" or 10 > 3)  # Ture

优先级：not>and>or

  • ① 三者的优先级关系：not>and>or，同一优先级默认从左往右计算。 ```python 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

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

print(1 > 0 or 1 != 1 or 3 > 2) # True

  2. <a name="334052b1"></a>
  3. ## 5、成员运算
  5. -  **in**与**not in**<br />判断某一个个体在不在某个群体内 
  6.    -  in ：某一个对象包含于另一个对象则返回True，字符串，列表，字典，集合，元祖都支持成员运算 
  7.    -  not in 某一个对象没有包含于另外一个对象则返回True 
  9. ![](https://gitee.com/gengff/blogimage/raw/master/images/123123_gaitubao_389x171.webp#id=Ebso3&originHeight=171&originWidth=389&originalType=binary&ratio=1&status=done&style=none)

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})

  2. <a name="8989c481"></a>
  3. ## 6、身份运算
  5. -  **is**与 **= =**<br />判断两个数据的值和内存地址是否相等 
  6.    -  is ：判断左右两个值内存地址（身份id）是否相等 
  7.    -  == ：判断左右两个值是否相等 
  9. ![](https://gitee.com/gengff/blogimage/raw/master/images/dasfas_gaitubao_296x246.webp#id=LDsKp&originHeight=246&originWidth=296&originalType=binary&ratio=1&status=done&style=none)<br />**注意：**<br />（1）如果内存地址（id）相等，意味着 type（类型） 和 value（值）必定相等
  11. ```python
  12. x = 1000
  14. y = x
  16. print(x is y)

（2）value （值）相等 type（类型）肯定相等，但内存地址（id）不一定相等

  1. C:\Users\oldboy>python3
  2. Python 3.8.6 (tags/v3.8.6:db45529, Sep 23 2020, 15:52:53) [MSC
  3. v.1927 64 bit (AMD64)] on win32
  4. Type "help", "copyright", "credits" or "license" for more 
  5. information.
  7. >>> x=1000
  9. >>> y=1000
  11. >>> id(x)x
  13. 2577369562032
  15. >>> id(y)
  17. 2577369562096
  19. >>>
  21. >>> x is y
  23. False
  25. >>> x == y
  27. True
  29. >>>

补充了解：布尔值分为两大类

  • 1、显式的布尔值：能明确地得到True或False，比如x=True,10 > 3, 10 > 3 and 1==1
    ```python 3 == 1 and True and 10 > 3

print(3 == 1 and True and 10 > 3) # False

  2. -  2、隐式的布尔值：所有的数据类型的值都可以当作隐式的布尔值，其中0、None、空对应隐式布尔值为False，其余对应隐式布尔值为True  
  3. ```python
  4. 10 and 3 and 4 > 2
  6. print(10 and 3 and 4 > 2)  # True
  8. print(10 and 0 and 4 > 2)  # 0
  10. print(0 and 2 or 1)  # 1