大数据技术之_23_Python核心基础学习_01_计算机基础知识 + Python 入门 (9.5小时)

第一章 计算机基础知识

1.1 课程介绍

课程名称:Python 基础视频教程 讲师:尚硅谷教育,李立超(lichao.li@foxmail.com) 面向的层次:From Zero to Hero(从入门到精通) 学习方法:认真听讲,多敲代码 必备技能:   ① 计算机基本操作   ② 打字的速度   ③ 英语(能阅读基本的英文文档)

1.2 计算机是什么

在现实生活中,越来越无法离开计算机了   电脑、笔记本、手机、游戏机、汽车导航、智能电视、…… 计算机就是一个用来计算的机器!!! 目前来讲,计算机只能根据人类的指令来完成各种操作,人让它干嘛他就得干嘛。 所以我们学习计算机,就是学习如何控制计算机!!!

1.3 计算机的组成

计算机由两部分组成:硬件 和 软件 硬件包含:键盘、鼠标、显示器、CPU、主板、内存、硬盘、……   硬件是看的见摸得着的。 软件包含:系统软件(Windows、MacOS、Linux)和应用软件(Office 、QQ、绝地求生)   软件是看的见摸不着的,软件负责控制计算机中的硬件。

1.4 计算机的使用方式

  我们必须要通过软件来对计算机完成各种操作,但是注意,软件中并不是所有的功能都会对用户开放,用户需要调用软件提供的接口(Interface 交互界面)来操作计算机。   用户界面分成两种:TUI(文本交互界面)和 GUI(图形化交互界面)

1.5 windows 的命令行

命令行就是文本交互界面,通过命令行可以使用一个一个的指令来操作计算机。 任何的计算机的操作系统中都包含有命令行(windows、linux、macOS) 命令行有多个不同的名字:   命令行、命令行窗口、DOS 窗口、命令提示符、CMD 窗口、Shell、终端、Terminal • 练习1:通过搜索引擎来搜索一下,各个操作系统当中的命令行窗口的样式。 • 练习2:尝试使用多种方式进入到你的系统的命令行,并且观察你的和我的有什么区别? • 练习3:通过搜索引擎搜索一下其他的一些常用 DOS 命令,并尝试使用一些命令的选项。

1.如何进入到命令行
    win键 + R 出现运行窗口,输入cmd,然后回车
2.命令行的结构
    - 版本及版权声明(一般没有什么用)
        Microsoft Windows [版本 10.0.17763.475]
        (c) 2018 Microsoft Corporation。保留所有权利。

    - 命令提示符
        C:\Users\bruce>
            C:  
                - 当前所在的磁盘根目录
                - 可以通过 x: 来切换盘符(x表示你的盘符)
            \Users\bruce
                - 所在磁盘的路径,当前所在的文件夹
                - cd 来切换目录
            >
                - 命令提示符,在大于号后边可以直接输入指令

3.常用的 dos 命令
    dir 查看当前目录下的所有文件(夹)
    cd  进入到指定的目录
            . 表示当前目录
            .. 表示上一级目录
    md  创建一个目录
    rd  删除一个目录    
    del 删除一个文件
    cls 清除屏幕

    命令的语法:
        命令 [参数] [选项]

4.小技巧
    - 方向键上下,查看命令的历史记录
    - tab 键自动补全命令   

1.6 环境变量(environment variable)

环境变量指的就是操作系统当中的一些变量。 可以通过修改环境变量,来对计算机进行配置(主要是来配置一些路径的)。

1.查看环境变量
    > 右键 -> 计算机(此电脑) -> 选择属性
    > 系统界面左侧选择 -> 高级系统设置
    > 选择环境变量
    环境变量界面分成了两个部分,上边是用户环境变量,下边是系统环境变量
    建议:只修改用户的环境变量,不要修改系统的环境变量。

2.添加环境变量
    > 通过新建按钮添加环境变量
    > 一个环境变量可以由多个值,值与值之间使用;(英文)隔开

3.修改环境变量
    > 通过编辑按钮来修改环境变量

4.删除环境变量
    > 通过删除按钮来删除环境变量

• 练习4:进入到环境变量的界面,创建一个 USERNAME 环境变量,修改 USERNAME 环境变量,并尝试添加多个值,然后删除 USERNAME 环境变量。

1.7 path 环境变量

path 环境变量中保存的是一个一个的路径。 当我们在命令行中输入一个命令(或访问一个文件时),   • 系统会首先在当前目录下寻找,如果找到了则直接执行或打开。   • 如果没有找到,则会依次去 path 环境变量的路径中去寻找,直到找到为止。   • 如果 path 环境变量中的路径都没有找到,则报错。如下:   • 'xxx' 不是内部或外部命令,也不是可运行的程序或批处理文件。

我们可以将一些经常需要访问到的文件会程序的路径,添加到path环境变量中,   这样我们就可以在任意的位置访问到这些文件了

注意事项:   1.如果环境变量中没有path,可以手动添加   2.path 环境变量不区分大小写,PATH Path path 均可   3.修改完环境变量必须重新启动命令行窗口   4.多个路径之间使用;隔开

• 练习5:在桌面创建一个 hello 文件夹,文件中创建一个 abc.txt 输入随意的内容,然后将 hello 的路径添加到 path 环境变量中,尝试在任意位置访问 abc.txt,最后将 hello 路径从 path 环境变量中删除。

1.8 进制

- 十进制(最常用的进制)
    - 十进制就是满十进一的进制
    - 十进制当中一共有 10 个数字
        0 1 2 3 4 5 6 7 8 9
    - 十进制如何计数
        0 1 2 3 4 5 6 7 8 9 10 11 12 。。。 19 20 。。。29 30

- 二进制(计算机底层使用的进制)
    - 满二进一
    - 二进制中一共有 2 个数字
        0 1
    - 二进制如何计数
        0 1 10 11 100 101 110 111 1000
    - 所有的数据在计算机底层都是以二进制的形式保存的,计算机只认二进制。
    - 可以将内存想象为一个一个的小格子,小格子中可以存储一个0或一个1。
    - 内存中的每一个小格子,我们称为 1bit(位)。
        bit 是计算机中的最小的单位
        byte 是我们最小的可操作的单位
        8bit = 1byte(字节)    
        1024byte = 1kb(千字节) 
        1024kb = 1mb(兆字节)
        1024mb = 1gb(吉字节)
        1024gb = 1tb(太字节)
        。。。

- 八进制(一般不用)
    - 满八进一
    - 八进制中一共有 8 个数字
        0 1 2 3 4 5 6 7
    - 八进制如何计数
        0 1 2 3 4 5 6 7 10 11 。。。 17 20 。。。27 30

- 十六进制
    - 满十六进一
    - 十六进制中一共有 16 个数字
        由于十六进制是满 16 才进位,所以十六进制中引入了a b c d e f来表示 10 11 12 13 14 15   
        0 1 2 3 4 5 6 7 8 9 a b c d e f 
    - 十六进制如何计数    
        0 1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 。。。 1a 1b 1c 1d 1e 1f
        20 21 22 。。。 2a 2b 2c 2d 2e 2f 30    
    - 我们在查看二进制数据时,一般会以十六进制的形式显示。

1.9 文本文件和字符集

- 文本分成两种,一种叫做纯文本,还有一种叫做富文本。
- 纯文本中只能保存单一的文本内容,无法保存内容无关的东西(字体、颜色、图片、......)
- 富文本中可以保存文本以外的内容(word 文档)
- 在开发时,编写程序使用的全都是纯文本!

- 纯文本在计算机底层也会转换为二进制保存,
    将字符转换为二进制码的过程,我们称为 编码
    将二进制码转换为字符的过程,我们称为 解码
    编码和解码时所采用的规则,我们称为 字符集

- 常见的字符集:
    ASCII
        - 美国人编码,使用 7 位来对美国常用的字符进行编码。
        - 包含 128 个字符
    ISO-8859-1
        - 欧洲的编码,使用 8 位。
        - 包含 256 个字符
    GB2312
    GBK
        国标码,中国的编码。
    Unicode   
        万国码,包含世界上所有的语言和符号,编写程序时一般都会使用 Unicode 编码。
        Unicode 编码有多种实现:UTF-8、UTF-16、UTF-32
        最常用的就是 UTF-8
- 乱码
    编写程序时,如果发现程序代码出现乱码的情况,就要马上去检查字符集是否正确。

1.10 Sublime Text 3

- 纯文本编辑器
- Package Control(Sublime 的包管理器)
    - Sublime Text3 中的插件,通过该插件可以向 Sublime 中安装新的包。

• 练习6:   1、安装 Sublime Text3   2、在 Sublime 中安装 Package Control   3、通过 Package Control 安装 Sublime 的中文语言包   4、尝试为你的 Sublime 安装新的主题(通过搜索引擎搜索) 注意:由于 packagecontrol.io 被墙了,需要使用全局的梯子可以解决问题(推荐使用全局的梯子),或者可以离线安装 Package。

第二章 Python 入门

2.1 什么是计算机语言

计算机就是一台用来计算机的机器,人让计算机干什么计算机就得干什么!
需要通过计算机的语言来控制计算机(编程语言)!

计算机语言其实和人类的语言没有本质的区别,不同点就是交流的主体不同!

计算机语言发展经历了三个阶段:
    机器语言
        - 机器语言通过二进制编码来编写程序。
        - 执行效率好,编写起来太麻烦。

    符号语言(汇编)
        - 使用符号来代替机器码。
        - 编写程序时,不需要使用二进制,而是直接编写符号。
        - 编写完成后,需要将符号转换为机器码,然后再由计算机执行。
            符号转换为机器码的过程,称为汇编。
            将机器码转换为符号的过程,称为反汇编。
        - 汇编语言一般只适用于某些硬件,兼容性比较差。

    高级语言
        - 高级语言的语法基本和现在英语语法类似,并且和硬件的关系没有那么紧密了。
        - 也就是说我们通过高级语言开发程序可以在不同的硬件系统中执行。
        - 并且高级语言学习起来也更加的容易,现在我们知道的语言基本都是高级语言。
        - C、C++、C#、Java、JavaScript、Python、Scala、Go、PHP、......

2.2 编译型语言和解释型语言

计算机只能识别二进制编码(机器码),所以任何的语言在交由计算机执行时必须要先转换为机器码,也就是像 print('hello') 必需要转换为类似 1010101 这样的机器码。  

根据转换时机的不同,语言分成了两大类:
    编译型语言
        - C语言
        - 编译型语言,会在代码执行前将代码编译为机器码,然后将机器码交由计算机执行。
        - a(源码) --> 编译器 --> b(编译后的机器码)
        - 特点:
            执行速度特别快
            跨平台性比较差

    解释型语言 
        - Python JS Java
        - 解释型语言,不会在执行前对代码进行编译,而是在执行的同时一边执行一边编译。
        - a(源码)--> 解释器 --> 解释执行  
        - 特点:
            执行速度比较慢
            跨平台性比较好  

2.3 Python 的介绍

Python 是解释型语言。

Python(英国发音:/ˈpaɪθən/ 美国发音:/ˈpaɪθɑːn/),是一种广泛使用的高级编程语言,属于通用型编程语言,由 【吉多·范罗苏姆(龟叔)】 创造,第一版发布于 1991 年。
可以视之为一种改良(加入一些其他编程语言的优点,如面向对象)的 LISP。作为一种解释型语言,Python 的设计哲学强调代码的可读性和简洁的语法(尤其是使用空格缩进划分代码块,而非使用大括号或者关键词)。
相比于 C++ 或 Java,Python 让开发者能够用更少的代码表达想法。不管是小型还是大型程序,该语言都试图让程序的结构清晰明了。 

Life is short, you need Python. (人生苦短,我用 Python。)    

Python 的用途:
    WEB应用(网站),不突出应用
        Facebook、豆瓣、谷歌后台、......
    爬虫程序,突出应用
    科学计算,突出应用
        计算能力强,精度高
    自动化运维
        Linux 服务器,脚本
    大数据
        ETL
    云计算
        阿里云、腾讯云、京东云、....
    桌面软件/游戏
    人工智能,突出应用
        阿尔法狗、...
    ......   

2.4 Python 开发环境搭建

开发环境搭建就是安装 Python 的解释器。

Python 的解释器分类:
    CPython(官方)
        用 C 语言编写的 Python 解释器
    PyPy
        用 Python 语言编写的 Python 解释器
    IronPython
        用 .net 编写的 Python 解释器
    Jython
        用 Java 编写的 Python 解释器

步骤:
    1. 下载安装包 python-3.7.2.exe,是用 C 语言编写的 Python 解释器
        - 3.x
        - 2.x  
        3.x 与 2.x 不兼容
    2. 安装(傻瓜式安装) 
    3. 打开命令行窗口,输入 python 出现如下内容:
        Python 3.7.2 (tags/v3.7.2:9a3ffc0492, Dec 23 2018, 23:09:28) [MSC v.1916 64 bit (AMD64)] on win32
        Type "help", "copyright", "credits" or "license" for more information.
        >>>

2.5 Python 的交互界面

当我们通过命令行来输入 Python,所进入到的界面就是 Python 的交互界面。

结构:
    版本和版权声明:
    Python 3.7.2 (tags/v3.7.2:9a3ffc0492, Dec 23 2018, 23:09:28) [MSC v.1916 64 bit (AMD64)] on win32
    Type "help", "copyright", "credits" or "license" for more information.
    >>>

    命令提示符:
    >>>

    在命令提示符后可以直接输入 Python 的指令!输入完的指令将会被 Python 的解释器立即执行!

    安装 Python 的同时,会自动安装一个 Python 的开发工具 IDLE,通过 IDLE 也可以进入到交互模式。如下图所示:
    但是不同的是,在 IDLE 中可以通过 TAB 键来查看语句的提示。
    IDLE 实际上就是一个交互界面,但是他可以有一些简单的提示,并且可以将代码保存。

    交互模式只能你输入一行代码,它就是执行一行,所以他并不适用于我们日常的开发! 仅可以用来做一些日常的简单的测试!   

    我们一般会将 Python 代码编写到一个 py 文件中,然后通过 python 指令来执行文件中的代码。如下图所示:

• 练习7:   自己尝试创建一个py文件,并向文件中写入python打印语句(print…),然后执行该文件。如果你的系统的扩展名无法修改,请尝试自行 baidu!答:因为 windows 系统中默认是隐藏文件扩展名和类型。需要我们设置打开。

Python 的开发工具 IDLE

简单演示使用

2.6 Python 和 Sublime 的整合

1.在 Sublime 中执行 Python 代码,使用 Ctrl + b 自动会在 Sublime 内置的控制台中执行
注意:这种执行方式,在某些版本的 Sublime 中对中文支持不好,并且不能使用 input() 函数。

2.使用 SublimeREPL 来运行 python 代码    
先安装 SublimeREPL,安装完成后,设置快捷键,按 f5 则自动执行当前的 Python 代码。

首选项 --> 快捷设置 --> 在 用户配置(User) --> 输入以下内容:
{ "keys": ["f5"], "caption": "SublimeREPL:Python","command": "run_existing_window_command", "args":{"id": "repl_python_run","file": "config/Python/Main.sublime-menu"}},

2.7 几个概念区分

1.表达式(expression)
    表达式就是一个类似于数学公式的东西。
    比如:10 + 5   8-4
    表达式一般仅仅用了计算一些结果,不会对程序产生实质性的影响。
    如果在交互模式中输入一个表达式,解释器会自动将表达式的结果输出。

2.语句(statement)
    在程序中语句一般需要完成某种功能,比如:打印信息、获取信息、为变量赋值、.......。
    比如:
        print()
        input()
        a = 10
    语句的执行一般会对程序产生一定的影响。
    在交互模式中不一定会输出语句的执行结果。

3.程序(program)
    程序就是由一条一条的语句和一条一条的表达式构成的。

4.函数(function)
    函数就是一种语句,函数专门用来完成特定的功能。
    函数长的形如:xxx()          

    函数的分类:
        内置函数
            - 由 Python 解释器提供的函数,可以在 Python 中直接使用。
        自定义函数   
            - 由程序员自主创建的函数。
    当我们需要完成某个功能时,就可以去调用内置函数,或者自定义函数。

    函数的两个要素:
        参数
            - () 中的内容就是函数的参数。
            - 函数中可以没有参数,也可以有多个参数,多个参数之间使用 , 隔开。
        返回值        
            - 返回值是函数的返回结果,不是所有的函数都有返回值。

2.8 基本语法

• 1.在 Python 中严格区分大小写。

• 2.Python中 的每一行就是一条语句,每条语句以换行结束。

• 3.Python 中每一行语句不要过长(规范中建议每行不要超过 80 个字符)。 Sublime Text 中设置:"rulers":[80],

• 4.一条语句可以分多行编写,多行编写时语句后边以 \ 结尾。

• 5.Python 是缩进严格的语言,所以在 Python 中不要随便写缩进。(Python 中缩进表示代码块)

• 6.在 Python 中使用 # 来表示注释,# 后的内容都属于注释,注释的内容将会被解释器所忽略。   我们可以通过注释来对程序进行解释说明,一定要养成良好的编写注释的习惯。   注释要求简单明了,一般习惯上 # 后边会跟着一个空格。好习惯!!!

注释快捷键 Ctrl + / 换行快捷键 Ctrl + Enter

2.9 字面量和变量

字面量就是一个一个的值,比如:1,2,3,4,5,6,'HELLO'
    字面量所表示的意思就是它的字面的值,在程序中可以直接使用字面量。

变量(variable)变量可以用来保存字面量,并且变量中保存的字面量是不定的。
    变量本身没有任何意思,它会根据不同的字面量表示不同的意思。

一般我们在开发时,很少直接使用字面量,都是将字面量保存到变量中,通过变量来引用字面量。

2.10 变量和标识符

# Python 中使用变量,不需要声明,直接为变量赋值即可。
a = 10
print(a)

# 不能使用没有进行过赋值的变量。
# 如果使用没有赋值过的变量,会报错 NameError: name 'b' is not defined
# print(b)

# Python 是一个动态类型的语言,可以为变量赋任意类型的值,也可以任意修改变量的值。
a = 'hello'
print(a)

# 标识符:在 Python 中所有可以自主命名的内容都属于标识符。
# 比如:变量名、函数名、类名
# 标识符必须遵循标识符的规范
#   1. 标识符中可以含有字母、数字、_,但是不能使用数字开头。
#       例子:a_1 _a1 _1a
#   2. 标识符不能是 Python 中的关键字和保留字。
#       也不建议使用 Python 中的函数名作为标识符,因为这样会导致函数被覆盖。
#   3. 命名规范:
#       在 Python 中注意遵循两种命名规范:
#           1) 下划线命名法(Python 中常用此法)
#               所有字母小写,单词之间使用_分割
#               示例:max_length、min_length、hello_world、xxx_yyy_zzz
#           2) 帕斯卡命名法(大驼峰命名法)(Python 中写类名时常用此法)
#               首字母大写,每个单词开头字母大写,其余字母小写
#               示例:MaxLength、MinLength、HelloWorld、XxxYyyZzz  
#       
#   如果使用不符合标准的标识符,将会报错 SyntaxError: invalid syntax    
#   练习:尝试自己定义几个变量(复杂一些,尝试不同的命名法),然后打印一些变量。通过搜索引擎搜索还有哪些其他的命名规范。

_b123 = 20
# print(_b123)

# print = 123
# print(print)

关键字

2.11 数据类型

数据类型指的就是变量的值的类型,也就是可以为变量赋哪些值。

    1.数值类型
        整型
            布尔值
        浮点型
        复数(后面讲解)
    2.字符串类型
    3.空值类型

2.11.1 数值类型

数值类型--示例代码:

# 在 Python 中,数值分成了三种:整数、浮点数(小数)、复数
# 在 Python 中所有的整数都是 int 类型
a = 10
b = 20
# Python 中的整数的大小没有限制,可以是一个无限大的整数
# c = 999999999999999999999999999999999999999999999 ** 100      # 1个 * 表示乘法,2个 * 表示多少次幂

# 如果数字的长度过大,可以使用下划线作为分隔符
c = 123_456_789

# d = 0123      十进制的数字不能以0开头
# 其他进制的整数,注意:只要是数字打印时一定是以十进制的形式显示的。
# 二进制 0b开头
c = 0b10 # 二进制的10
# 八进制 0o开头
c = 0o10
# 十六进制 0x开头
c = 0x10

# 也可以通过运算符来对数字进行运算,并且可以保证整数运算的精确。
c = -100
c = c + 3   # 表达式

# 浮点数(小数),在 Python 中所有的小数都是 float 类型。
c = 1.23
c = 4.56

# 对浮点数进行运算时,可能会得到一个不精确的结果
c = 0.1 + 0.2       # 0.30000000000000004

print(c)

2.11.2 字符串类型

字符串类型--示例代码:

# 字符串(str)
# 字符串用来表示一段文本信息,字符串是程序中使用的最多的数据类型。
# 在 Python 中字符串需要使用引号引起来。

s = 'hello'
# s = abc   # 字符串必须使用引号引起来,不使用引号引起来则不是字符串。
# 引号可以是双引号,也可以是单引号,但是注意不要混着用。
s = 'hello'
s = "hello"
# s = 'hello"   # 引号不能混合使用,否则报错:SyntaxError: EOL while scanning string literal

# 相同的引号之间不能嵌套
# s = "子曰:"学而时习之,乐呵乐呵!""
s = '子曰:"学而时习之,乐呵乐呵!"'

# 长字符串
# 单引号和双引号不能跨行使用。
s = '锄禾日当午,\
汗滴禾下土,\
谁知盘中餐,\
粒粒皆辛苦'

# 使用三重引号来表示一个长字符串 '''  """
# 三重引号可以换行,并且会保留字符串中的格式。

s = '''锄禾日当午,
汗滴禾下土,
谁知盘中餐,
粒粒皆辛苦'''

# 转义字符
# 可以使用 \ 作为转义字符,通过转义字符,可以在字符串中使用一些特殊的内容。
# 例子:
#   \' 表示 '
#   \" 表示 "
#   \t 表示 制表符
#   \n 表示 换行符
#   \\ 表示 反斜杠
#   \uxxxx 表示 Unicode编码
s = "子曰:\"学而时习之,\\\\n乐呵乐呵!\""
print(s)    # 子曰:"学而时习之,\\n乐呵乐呵!"

s = '\u0040'
print(s)    # @

2.11.3 4 种格式化字符串的方式

格式化字符串--示例代码:

# 格式化字符串
a = 'hello'

# 字符串之间也可以进行加法运算。
# 如果将两个字符串进行相加,则会自动将两个字符串拼接为一个字符串。
a = 'abc' + 'haha' + '哈哈'
# a = 123 
# 字符串不能和其他的类型进行加法运算,如果做了会出现异常:TypeError: must be str, not int
# print("a = " + a)     # 方式一:a = 123   使用字符串拼接的方式,这种写法在 Python 中不常见!!!
a = 123
# print('a =', a)       # 方式二:a = 123   使用 print() 函数的打印多个参数的方式,输出的多个参数之间使用空格隔开!

# 在创建字符串时,可以在字符串中指定占位符
# %s 在字符串中表示任意字符
# %f 浮点数占位符
# %d 整数占位符
b = 'hello %s' %'孙悟空'        # hello 孙悟空
b = 'hello %s 你好 %s' %('tom', '孙悟空')    # hello tom 你好 孙悟空
b = 'hello %3.5s' %'abcdefg'    # %3.5s 字符串的长度限制在3-5之间,如果不够,前头用空格补
b = 'hello %s' %123.456         # hello 123.456
b = 'hello %.2f' %123.456       # hello 123.46
b = 'hello %d' %123.95          # hello 123
b = '呵呵'

# print('a = %s' %a)    # 方式三:a = 123   使用占位符的方式

# 格式化字符串,可以通过在字符串前添加一个f(或F)来创建一个格式化字符串。
# 在格式化字符串中可以直接嵌入变量
c = f'hello {a} {b}'

print(f'a = {a}')       # 方式四:a = 123   使用格式化字符串的方式

练习8、创建一个变量保存你的名字,然后通过四种格式化字符串的方式,在命令行中显示,欢迎 xxx 光临

name = '悟空'

# 1、字符串拼接的方式
print('欢迎 ' + name + ' 光临')

# 2、print() 函数的打印多个参数
print('欢迎', name, '光临')

# 3、占位符
print('欢迎 %s 光临' %name)

# 4、格式化字符串
print(f'欢迎 {name} 光临')

输出结果如下:

欢迎 悟空 光临
欢迎 悟空 光临
欢迎 悟空 光临
欢迎 悟空 光临

2.11.4 字符串复制

字符串复制--示例代码:

# 字符串的复制(将字符串和数字相乘)
a = 'abc'
# * 在语言中表示乘法
# 如果将字符串和数字相乘,则解释器会将字符串重复指定的次数并返回
a = a * 3

print(a)    # abcabcabc

2.11.5 布尔值 和 空值

布尔值 和 空值--示例代码:

# 布尔值(bool)
# 布尔值主要用来做逻辑判断
# 布尔值一共有两个 True 和 False
# True 表示真   False 表示假
a = True
a = False
# print('a =', a)   # a = False

# 布尔值实际上也属于整型,True 就相当于 1,False 就相当于 0
# print(1 + False)

# None(空值)
# None 专门用来表示不存在
b = None
print(b)    # None

2.12 类型检查

类型检查--示例代码:

# 通过类型检查,可以检查指定值(变量)的类型

a = 123     # 数值
b = '123'   # 字符串

# print('a =', a)
# print('b =', b)

# type() 函数用来检查值的类型。
# 该函数会将检查的结果作为返回值返回,可以通过变量来接收函数的返回值。

c = type('123')
c = type(a)
# print(c)
# print(type(b))

print(type(1))          # <class 'int'>
print(type(1.5))        # <class 'float'>
print(type(True))       # <class 'bool'>
print(type('hello'))    # <class 'str'>
print(type(None))       # <class 'NoneType'>

2.13 对象(object)

- Python 是一门面向对象的语言。
- 一切皆对象!
- 程序运行当中,所有的数据都是存储到内存当中然后再运行的!
- 对象就是内存中专门用来存储指定数据的一块区域。
- 对象实际上就是一个容器,专门用来存储数据。
- 像我们之前学习的数值、字符串、布尔值、None 都是对象。

2.14 对象的结构

- 每个对象中都要保存三种数据
    - id(标识)
        > id 用来标识对象的唯一性,每一个对象都有唯一的 id
        > 对象的 id 就相当于人的身份证号一样
        > 可以通过 id() 函数来查看对象的 id
        > id 是由解析器生成的,在 CPython 中,id 就是对象的内存地址
        > 对象一旦创建,则它的 id 永远不能再改变

    - type(类型)
        > 类型用来标识当前对象所属的类型
        > 比如:int、str、float、bool、......
        > 类型决定了对象有哪些功能
        > 通过 type() 函数来查看对象的类型
        > Python 是一门强类型的语言,对象一旦创建类型便不能修改

    - value(值)
        > 值就是对象中存储的具体的数据
        > 对于有些对象值是可以改变的
        > 对象分成两大类,可变对象 和 不可变对象
            可变对象的值可以改变
            不可变对象的值不能改变,之前学习的对象都是不可变对象

内存小图解:

2.15 变量和对象

- 对象并没有直接存储到变量中,在 Python 中变量更像是给对象起了一个别名
- 变量中存储的不是对象的值,而是对象的 id(内存地址)
    当我们使用变量时,实际上就是在通过对象 id 在查找对象
- 变量中保存的对象,只有在为变量重新赋值时才会改变
- 变量和变量之间是相互独立的,修改一个变量不会影响另一个变量

变量和对象的图解:

2.16 类型转换

- 所谓的类型转换,将一个类型的对象转换为其他对象。
- 类型转换不是改变对象本身的类型,而是根据当前对象的值创建一个新对象!!!

类型转换--示例代码:

# 类型转换的四个函数 int() float() str() bool()

# int() 可以用来将其他的对象转换为整型
# 规则:
#   布尔值:True -> 1   False -> 0
#   浮点数:直接取整,省略小数点后的内容
#   字符串:合法的整数字符串,直接转换为对应的数字
#           如果不是一个合法的整数字符串,则报错 ValueError: invalid literal for int() with base 10: '11.5'
#   对于其他不可转换为整型的对象,直接抛出异常 ValueError

# float() 和 int() 基本一致,不同的是它会将对象转换为浮点数

# str() 可以将对象转换为字符串
#   True -> 'True'
#   False -> 'False'
#   123 -> '123' 

# bool() 可以将对象转换为布尔值,任何对象都可以转换为布尔值
#   规则:对于所有表示空性的对象都会转换为 False,其余的转换为 True
#           有哪些表示的空性:0 、 None 、 '' 、...

a = True

# 调用 int() 来将 a 转换为整型
# int() 函数不会对原来的变量产生影响,它是将对象转换为指定的类型并将其作为返回值返回
# 如果希望修改原来的变量,则需要对原来的变量进行重新赋值

a = int(a)  # 1

a = False
a = int(a)  # 0

a = '123'
a = int(a)  # 123

a = 11.6
a = int(a)  # 11

a = '11.5'
# a = int(a)    # 报错,如果不是一个合法的整数字符串,则报错

a = None
# a = int(a)    # 报错,如果是一个NoneType,则报错

a = 1
a = float(a)    # 1.0

a = False
a = float(a)    # 0.0

a = 123
a = str(a)      # '123'

a = None
a = bool(a)     # False

print('a =', a)
print('a的类型是', type(a))

# b = 456
print('hello' + str(b))     # 'hello456'

2.17 运算符(操作符)

- 运算符可以对一个值或多个值进行运算或各种操作
- 比如 + 、-、= 都属于运算符
- 运算符的分类:
    1.算术运算符
    2.赋值运算符
    3.比较运算符(关系运算符)
    4.逻辑运算符
    5.条件运算符(三元运算符)    

2.17.1 算术运算符

算术运算符--示例代码:

# 算术运算符
#   + 加法运算符(如果是两个字符串之间进行加法运算,则会进行拼串操作)
#   - 减法运算符
#   * 乘法运算符(如果将字符串和数字相乘,则会对字符串进行复制操作,将字符串重复指定次数)
#   / 除法运算符,运算时结果总会返回一个浮点类型
#   // 整除,只会保留计算后的整数位,总会返回一个整型
#   ** 幂运算,求一个值的几次幂
#   % 取模,求两个数相除的余数

a = 10 + 5      # 计算
a = 'hello' + ' ' + 'world'     # 拼串

a = 10 - 5      # 计算
a = 5 - True 
a = a - 2       # 用变量 a 的值减去 2,然后再赋值给 a
# a = 'hello' - 'h'     # 报错:TypeError

a = 5 * 5

a = 10 / 5      # 2.0
a = 5 / 2       # 2.5
# a = 5 / 0     # 报错:ZeroDivisionError: division by zero

a = 10 / 3      # a = 3.3333333333333335
a = 10 // 3     # a = 3     即取商
a = 5 // 2      # a = 2

a = 2 ** 2      # 2^2 = 4
a = 10 ** 5     # 10^5 = 100000
a = 16 ** 0.5   # 16^0.5 = 4.0     即求16的平方根

a = 10 % 5      # 0     即取余
a = 10 % 4      # 2     即取余
a = 10 % 3      # 1     即取余
a = 10 % 2      # 0     即取余

print("a =", a)

2.17.2 赋值运算符

赋值运算符--示例代码:

# 赋值运算符
#   = 可以将等号右侧的值赋值给等号左侧的变量
#   +=      a += 5  相当于  a = a + 5 
#   -=      a -= 5  相当于  a = a - 5 
#   *=      a *= 5  相当于  a = a * 5 
#   **=     a **= 5 相当于  a = a ** 5 
#   /=      a /= 5  相当于  a = a / 5 
#   //=     a //= 5 相当于  a = a // 5 
#   %=      a %= 5  相当于  a = a % 5 

a = 25.0    # 在对浮点数做算术运算时,结果也会返回一个浮点数
a //= 5     # 5.0

a = 5
a %= 4      # 1

print('a =', a)

2.17.3 比较运算符(关系运算符)

比较运算符(关系运算符)--示例代码:

# 关系运算符
#   用来比较两个值之间的关系,总会返回一个布尔值
# 如果关系成立,返回 True,否则返回 False

#   >   比较左侧值是否大于右侧值
#   >=  比较左侧的值是否大于或等于右侧的值
#   <   比较左侧值是否小于右侧值
#   <=  比较左侧的值是否小于或等于右侧的值

#   ==  比较两个对象的值是否相等
#   !=  比较两个对象的值是否不相等
#           相等和不等比较的是对象的值,而不是 id

#   is  比较两个对象是否是同一个对象,比较的是对象的 id
#   is not  比较两个对象是否不是同一个对象,比较的是对象的 id

result = 10 > 20    # False
result = 30 > 20    # True
result = 30 < 20    # False
result = 10 >= 10   # True

result = 2 > True   # True
# result = 2 > '1'  # TypeError: '>' not supported between instances of 'int' and 'str'

# 0032 > 0031
result = '2' > '1'  # True      逐位比较
result = '2' > '11' # True      逐位比较

# 在 Python 中可以对两个字符串进行大于(等于)或小于(等于)的运算
#   当对字符串进行比较时,实际上比较的是字符串的 Unicode 编码
#   比较两个字符串的 Unicode 编码时,是【逐位比较】的
#       利用该特性可以对字符串按照字母顺序进行排序,但是对于中文来说意义不是特别大
#   注意:如果不希望比较两个字符串的 Unicode 编码,则需要将其转换为数字然后再比较

# 0061 > 0062
result = 'a' > 'b'  # False     逐位比较

result = 'c' < 'd'  # True      逐位比较
result = 'ab' > 'b' # False     逐位比较

# print(int('2') > int('11'))   # False

result = 1 == 1                 # True  比较两个对象的值是否相等
result = 'hello' == 'hello'     # True
result = 'abc' == 'bcd'         # False
result = 'abc' != 'bcd'         # True
result = 1 == True              # True
result = 1 is True              # False 比较两个对象是否是同一个对象,比较的是对象的 id
result = 1 is not True          # True

print('result =', result)
print(id(1), id(True))          # 140714389791568 140714389260624

2.17.4 逻辑运算符

比逻辑运算符--示例代码:

# 逻辑运算符
#   逻辑运算符主要用来做一些逻辑判断

# not 逻辑非
#   not 可以对符号右侧的值进行非运算
#       对于布尔值,非运算会对其进行取反操作,True 变 False,False 变 True
#       对于非布尔值,非运算会先将其转换为布尔值,然后再取反
#       
# and 逻辑与
#   and 可以对符号两侧的值进行与运算
#       只有在符号两侧的值都为 True 时,才会返回 True,只要有一个 False 就返回 False
#       【与运算是找 False 的】
#       Python 中的与运算是【短路的与】,如果第一个值为 False,则不再看第二个值
#   
# or 逻辑或
#   or 可以对符号两侧的值进行或运算
#       或运算两个值中只要有一个 True,就会返回 True
#       【或运算是找 True 的】
#       Python 中的或运算是【短路的或】,如果第一个值为 True,则不再看第二个值
#    
# 练习:
#       尝试一下对布尔值进行三种逻辑运算
#       尝试对非布尔值进行三种逻辑运算,并观察返回的结果

a = True
a = not a       # False 对 a 进行非运算

a = 1
a = not a
# print('a =', a)   # False

a = ''
a = not a
# print('a =', a)   # True

result = True and True      # True
result = True and False     # False
result = False and True     # False
result = False and False    # False

# print(result) 

# True and print('你猜我出来吗?')      第一个值是 True,会看第二个值,所以 print() 会执行
# False and print('你猜我出来吗?')     第一个值是 False,不会看第二个值,所以 print() 不会执行

result = True or True       # True
result = True or False      # True
result = False or True      # True
result = False or False     # False

# print(result) 

# False or print('你猜我出来吗?')      第一个值为 False,继续看第二个,所以打印语句执行
# True or print('你猜我出来吗?')       第一个值为 True,不看第二个,所以打印语句不执行


# 非布尔值的与或运算
#   当我们对非布尔值进行与或运算时,Python 会将其当做布尔值运算,最终会返回原值!!!
#   与运算的规则:
#       【与运算是找 False 的】,如果第一个值是 False,则不看第二个值
#       如果第一个值是 False,则直接返回第一个值,否则返回第二个值
#   或运算的规则:
#       【或运算是找 True 的】,如果第一个值是 True,则不看第二个值
#       如果第一个值是 True,则直接返回第一个值,否则返回第二个值    

# True and True
result = 1 and 2    # 2
# True and False
result = 1 and 0    # 0
# False and True
result = 0 and 1    # 0
# False and False
result = 0 and None # 0

# True or True
result = 1 or 2     # 1
# True or False
result = 1 or 0     # 1
# False or True
result = 0 or 1     # 1
# False or False
result = 0 or None  # None

print(result)

2.17.4 条件运算符(三元运算符)

条件运算符(三元运算符)--示例代码:

# 条件运算符(三元运算符)
#   语法: 语句1 if 条件表达式 else 语句2
# 执行流程:
#   条件运算符在执行时,会先对条件表达式进行求值判断:
#       如果判断结果为 True,则执行语句 1,并返回执行结果
#       如果判断结果为 False,则执行语句 2,并返回执行结果
# 练习:
#       现在有 a b c 三个变量,三个变量中分别保存有三个数值,
#       请通过条件运算符获取三个值中的最大值

# print('你好') if False else print('Hello')

a = 30
b = 50

# print('a的值比较大!') if a > b else print('b的值比较大!')

# 获取a和b之间的较大值
max = a if a > b else b

print(max)

a = 40
b = 50
c = 30

# 通过条件运算符获取三个值中的最大值
# max = a if a > b else b
# max = max if max > c else c

max = a if (a > b and a > c) else (b if b > c else c)   # 开发中不推荐这么使用
# max = a if (b < a > c) else (b if b > c else c)       # 逻辑运算符可以连着使用

# print(max)

2.17.5 运算符的优先级

# 运算符的优先级
#   和数学中一样,在 Python 运算也有优先级,比如:先乘除后加减

# 运算符的优先级可以根据优先级的表格来查询
#   在表格中位置越靠下的运算符优先级越高,优先级越高的越优先计算
#   如果优先级一样则自左向右计算

#  关于优先级的表格,你知道有这么一个东西就够了,千万不要去记
#  在开发中如果遇到优先级不清楚的,则可以通过小括号来改变运算顺序

a = 1 + 2 * 3

# 三种情况:一样高、and 高、or 高
# 如果 or 的优先级高,或者两个运算符的优先级一样高
#   则需要先进行 或运算,则运算结果是 3
# 如果 and 的优先级高,则应该先计算 与运算
#   则运算结果是 1

a = 1 or 2 and 3
print(a)    # 1

# 逻辑运算符(补充)
# 逻辑运算符可以连着使用
result = 1 < 2 < 3      # 相当于 1 < 2 and 2 < 3

result = 10 < 20 > 15   # 详当于 10 < 20 and 20 > 15
print(result)

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券