1、计算机核心基础

1.1 什么是语言？什么是编程语言？为何要有编程语言？

语言其实就是人与人之间沟通的介质，如英语，汉语，俄语等。
编程语言则是人与计算机之间沟通的介质,
编程的目的就是为了让计算机按照人类的思维逻辑(程序)自发地去工作从而把人力解放出来

二 计算机组成原理

2.1、什么是计算机？

俗称电脑，即通电的大脑，电脑二字蕴含了人类对计算机的终极期望，希望它能真的像人脑一样去工作，从而解放人力。

2.2、为什么要用计算机？

世界是由聪明的懒人统治的，任何时期，总有一群聪明的懒人想要奴隶别人。在奴隶制社会，聪明的懒人奴役的是真正的人，而人是无法不吃、不喝、不睡觉一直工作的，但是计算机作为一台机器是可以做到的，所以把计算机当奴隶是上上之选

2.3、计算机的五大组成部分

1.控制器:控制器是计算机的指挥系统，用来控制计算机其他组件的运行，相当于人类的大脑
2.运算器:运算器是计算机的运算功能，用来做算术运算和逻辑运算，相当于人脑
ps：控制器+运算器=CPU，cpu相当于人的大脑3.存储器:存储器是计算机的记忆功能，用来存取数据。存储器主要分为内存与外存：​ 内存相当于人的短期记忆。断电数据丢失​ 外存(如磁盘),相当于记事的本子，断电数据不会丢失，是用来永久保存数据的​ ps：内存的存取速度要远远高于外存
4.输入设备input:输入设备是计算接收外界输入数据的工具，如键盘、鼠标，相当于人的眼睛或耳朵。
5.输出设备output:输出设备是计算机向外输出数据的工具，如显示器、打印机，相当于人说的话，写出的文章。ps：存储器如内存、磁盘等既是输入设备又是输出设备，统称为IO设备

三大核心硬件为CPU、内存、硬盘。

程序最先是存放于硬盘中的，程序的运行是先从硬盘把代码加载到内存中，然后cpu是从内存中读取指令运行。

三 操作系统概述

3.1、操作系统的由来

操作系统的功能就是帮我们把复杂的硬件的控制封装成简单的接口，对于开发应用程序来说只需要调用操作系统提供给我们的接口即可

3.2、系统软件与应用软件

硬件以上运行的都是软件，而软件分为两类：

一、应用软件（例如qq、word、暴风影音，我们学习python就是为了开发应用软件的）二、操作系统，操作系统应用软件与硬件之间的一个桥梁，是协调、管理、控制计算机硬件与应用软件资源的控制程序。

3.3、计算机系统三层结构

应用程序
操作系统
计算机硬件

硬件 + 操作系统 == 平台

2、编程语言与Python介绍

编程语言分类：

机器语言

机器语言是站在计算机(奴隶)的角度，说计算机能听懂/理解的语言，而计算机能直接理解的就是二进制指令，所以机器语言就是直接用二进制编程，这意味着机器语言是直接操作硬件的，因此机器语言属于低级语言，此处的低级指的是底层、贴近计算机硬件

#机器语言用二进制代码0和1描述的指令称为机器指令，由于计算机内部是基于二进制指令工作的，所以机器语言是直接控制计算机硬件。用机器语言编写程序，编程人员要首先熟记所用计算机的全部指令代码以及代码的含义，然后在编写程序时，程序员得自己处理每条指令和每一数据的存储分配和输入输出，还得记住编程过程中每步所使用的工作单元处在何种状态。这是一件十分繁琐的工作。编写程序花费的时间往往是实际运行时间的几十倍或几百倍。而且，编出的程序全是些0和1的指令代码，直观性差，不便阅读和书写，还容易出错，且依赖于具体的计算机硬件型号，局限性很大。除了计算机生产厂家的专业人员外，绝大多数的程序员已经不再去学习机器语言了。机器语言是被微处理器理解和使用的，存在有多至100000种机器语言的指令，下述是一些简单示例#指令部份的示例0000 代表 加载（LOAD）0001 代表 存储（STORE）...#暂存器部份的示例0000 代表暂存器 A0001 代表暂存器 B...#存储器部份的示例000000000000 代表地址为 0 的存储器000000000001 代表地址为 1 的存储器000000010000 代表地址为 16 的存储器100000000000 代表地址为 2^11 的存储器#集成示例0000,0000,000000010000 代表 LOAD A, 160000,0001,000000000001 代表 LOAD B, 10001,0001,000000010000 代表 STORE B, 160001,0001,000000000001 代表 STORE B, 1[1]

总结机器语言

# 1、执行效率最高
编写的程序可以被计算机无障碍理解、直接运行，执行效率高 。# 2、开发效率最低
复杂，开发效率低# 3、跨平台性差
贴近\依赖具体的硬件，跨平台性差

汇编语言

汇编语言仅仅是用一个英文标签代表一组二进制指令，毫无疑问，比起机器语言，汇编语言是一种进步，但汇编语言的本质仍然是直接操作硬件，因此汇编语言仍是比较低级/底层的语言、贴近计算机硬件

#汇编语言
汇编语言的实质和机器语言是相同的，都是直接对硬件操作，只不过指令采用了英文缩写的标识符，更容易识别和记忆。它同样需要编程者将每一步具体的操作用命令的形式写出来。汇编程序的每一句指令只能对应实际操作过程中的一个很细微的动作。例如移动、自增，因此汇编源程序一般比较冗长、复杂、容易出错，而且使用汇编语言编程需要有更多的计算机专业知识，但汇编语言的优点也是显而易见的，用汇编语言所能完成的操作不是一般高级语言所能够实现的，而且源程序经汇编生成的可执行文件不仅比较小，而且执行速度很快。汇编的hello world，打印一句hello world, 需要写十多行，如下; hello.asm 
section .data            ; 数据段声明msg db "Hello, world!", 0xA     ; 要输出的字符串len equ $ - msg                 ; 字串长度section .text            ; 代码段声明global _start            ; 指定入口函数_start:                  ; 在屏幕上显示一个字符串mov edx, len     ; 参数三：字符串长度mov ecx, msg     ; 参数二：要显示的字符串mov ebx, 1       ; 参数一：文件描述符(stdout) mov eax, 4       ; 系统调用号(sys_write) int 0x80         ; 调用内核功能; 退出程序mov ebx, 0       ; 参数一：退出代码mov eax, 1       ; 系统调用号(sys_exit) int 0x80         ; 调用内核功能

总结汇编语言

# 1、执行效率高
相对于机器语言，使用英文标签编写程序相对简单，执行效率高，但较之机器语言稍低，# 2、开发效率低：
仍然是直接操作硬件，比起机器语言来说，复杂度稍低，但依旧居高不下，所以开发效率依旧较低# 3、跨平台性差
同样依赖具体的硬件，跨平台性差

高级语言

高级语言是站在人(奴隶主)的角度，说人话，即用人类的字符去编写程序，而人类的字符是在向操作系统发送指令，而非直接操作硬件，所以高级语言是与操作系统打交道的，此处的高级指的是高层、开发者无需考虑硬件细节，因而开发效率可以得到极大的提升，但正因为高级语言离硬件较远，更贴近人类语言，人类可以理解，而计算机则需要通过翻译才能理解，所以执行效率会低于低级语言。

按照翻译的方式的不同，高级语言又分为两种：

编译型（如C语言）:

类似谷歌翻译，是把程序所有代码编译成计算机能识别的二进制指令，之后操作系统会拿着编译好的二进制指令直接操作硬件，详细如下

# 1、执行效率高
编译是指在应用源程序执行之前，就将程序源代码“翻译”成目标代码（即机器语言），
因此其目标程序可以脱离其语言环境独立执行，使用比较方便，执行效率较高。# 2、开发效率低：
应用程序一旦需要修改，必须先修改源代码，然后重新编译、生成新的目标文件才能执行，
而在只有目标文件而没有源代码，修改会很不方便。所以开发效率低于解释型# 3、跨平台性差
编译型代码是针对某一个平台翻译的，当前平台翻译的结果无法拿到不同的平台使用，针对不同的平台必须重新编译，即跨平台性差# 其他
现在大多数的编程语言都是编译型的。
编译程序将源程序翻译成目标程序后保存在另一个文件中，该目标程序可脱离编译程序直接在计算机上多次运行。
大多数软件产品都是以目标程序形式发行给用户的，不仅便于直接运行，同时又使他人难于盗用其中的技术。
C、C++、Ada、Pascal都是编译实现的

解释型（如python）:

类似同声翻译，需要有一个解释器，解释器会读取程序代码，一边翻译一边执行，详细如下

# 1、执行效率低
解释型语言的实现中，翻译器并不产生目标机器代码，而是产生易于执行的中间代码。
这种中间代码与机器代码是不同的，中间代码的解释是由软件支持的，不能直接使用硬件，
软件解释器通常会导致执行效率较低。# 2、开发效率高
用解释型语言编写的程序是由另一个可以理解中间代码的解释程序执行的，与编译程序不同的是，
解释程序的任务是逐一将源程序的语句解释成可执行的机器指令，不需要将源程序翻译成目标代码再执行。
解释程序的优点是当语句出现语法错误时，可以立即引起程序员的注意，而程序员在程序开发期间就能进行校正。# 3、跨平台性强
代码运行是依赖于解释器，不同平台有对应版本的解释器，所以解释型的跨平台性强# 其他
对于解释型Basic语言，需要一个专门的解释器解释执行Basic程序，每条语句只有在执行时才被翻译，
这种解释型语言每执行一次就翻译一次，因而效率低下。一般地，动态语言都是解释型的，
例如：Tcl、Perl、Ruby、VBScript、JavaScript等

ps：混合型语言

java是一类特殊的编程语言，Java程序也需要编译，但是却没有直接编译为机器语言，而是编译为字节码，
然后在Java虚拟机上以解释方式执行字节码。

总结

综上选择不同编程语言来开发应用程序对比

#1、执行效率：机器语言>汇编语言>高级语言（编译型>解释型）#2、开发效率：机器语言<汇编语言<高级语言（编译型<解释型）#3、跨平台性：解释型具有极强的跨平台型

三 python介绍

谈及python，涉及两层意思，一层代表的是python这门语言的语法风格，另外一层代表的则是专门用来解释该语法风格的应用程序：python解释器。

Python崇尚优美、清晰、简单，是一个优秀并广泛使用的语言

Python解释器的发展史

从一出生，Python已经具有了：类，函数，异常处理，包含表和词典在内的核心数据类型，以及模块为基础的拓展系统。

Python解释器有哪些种类?

官方的Python解释器本质就是基于C语言开发的一个软件，该软件的功能就是读取以.py结尾的文件内容，然后按照Guido定义好的语法和规则去翻译并执行相应的代码。

# Jython
JPython解释器是用JAVA编写的python解释器，可以直接把Python代码编译成Java字节码并执行，它不但使基于java的项目之上嵌入python脚本成为可能，同时也可以将java程序引入到python程序之中。# IPython
IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的。这就好比很多国产浏览器虽然外观不同，但内核其实都是调用了IE。
CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。# PyPy
PyPy是Python开发者为了更好地Hack Python而用Python语言实现的Python解释器。PyPy提供了JIT编译器和沙盒功能，对Python代码进行动态编译（注意不是解释），因此运行速度比CPython还要快。# IronPython
IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。

四 安装Cpython解释器

Python解释器目前已支持所有主流操作系统，在Linux,Unix,Mac系统上自带Python解释器，在Windows系统上需要安装一下，具体步骤如下。

4.1、下载python解释器

https://www.python.org

4.2、安装python解释器

4.3、测试安装是否成功

windows --> 运行 --> 输入cmd ，然后回车，弹出cmd程序，输入python,如果能进入交互环境 ，代表安装成功。

五 第一个python程序

5.1 运行python程序有两种方式

方式一： 交互式模式

方式二：脚本文件

# 1、打开一个文本编辑工具，写入下述代码，并保存文件，此处文件的路径为D:\test.py。强调：python解释器执行程序是解释执行，解释的根本就是打开文件读内容，因此文件的后缀名没有硬性限制，但通常定义为.py结尾
print('hello world')# 2、打开cmd，运行命令，如下图

总结：

#1、交互式模式下可以即时得到代码执行结果，调试程序十分方便
#2、若想将代码永久保存下来，则必须将代码写入文件中
#3、我们以后主要就是在代码写入文件中，偶尔需要打开交互式模式调试某段代码、验证结果

5.2 注释

在正式学习python语法前，我们必须事先介绍一个非常重要的语法：注释

1、什么是注释

注释就是就是对代码的解释说明，注释的内容不会被当作代码运行

2、为什么要注释

增强代码的可读性

3、怎么用注释?

代码注释分单行和多行注释1、单行注释用#号，可以跟在代码的正上方或者正后方2、多行注释可以用三对双引号""" """

4、代码注释的原则：

1、不用全部加注释，只需要为自己觉得重要或不好理解的部分加注释即可2、注释可以用中文或英文，但不要用拼音

六 IDE工具pycharm的使用

在编写第一个python程序时，存在以下问题，严重影响开发效率

问题一：我们了解到一个python程序从开发到运行需要操作至少两个软件

1、打开一个软件：文本编辑器，创建文本来编写程序
2、打开cmd，然后输入命令执行pyton程序

问题二：在开发过程中，并没代码提示以及纠错功能

综上，如果能有一款工具能够集成n个软件的功能，同时又代码提示以及纠错等功能，那么将会极大地提升程序员的开发效率，这就是IDE的由来，IDE全称Integrated Development Environment，即集成开发环境，最好的开发Python程序的IDE就是PyCharm。

6.2、pychram安装

# 下载地址: https://www.jetbrains.com/pycharm/download  选择Professional专业版

6.3、Pycharm创建文件夹

6.4、如何创建文件并编写程序执行

创建py文件test.py

在test.py中写代码，输入关键字的开头可以用tab键补全后续，并且会有代码的错误提示

3、Python语法入门之变量

一 引入

我们学习python语言是为了控制计算机、让计算机能够像人一样去工作，所以在python这门语言中，所有语法存在的意义都是为了让计算机具备人的某一项技能，这句话是我们理解后续所有python语法的根本。

二 变量

一、什么是变量？

# 变量就是可以变化的量，量指的是事物的状态，比如人的年龄、性别，游戏角色的等级、金钱等等

二、为什么要有变量？

# 为了让计算机能够像人一样去记忆事物的某种状态，并且状态是可以发生变化的
# 详细地说：
# 程序执行的本质就是一系列状态的变化，变是程序执行的直接体现，所以我们需要有一种机制能够反映或者说是保存下来程序执行时状态，以及状态的变化。

三、怎么使用变量（先定义、后使用）

3.1、变量的定义与使用

定义变量示范如下

name = 'harry' # 记下人的名字为'harry'
sex = '男'    # 记下人的性别为男性
age = 18      # 记下人的年龄为18岁
salary = 30000.1  # 记下人的薪资为30000.1元

解释器执行到变量定义的代码时会申请内存空间存放变量值，然后将变量值的内存地址绑定给变量名，以变量的定义age=18为例，如下图

插图：定义变量申请内存

通过变量名即可引用到对应的值

# 通过变量名即可引用到值，我们可以结合print()功能将其打印出来
print(age) # 通过变量名age找到值18，然后执行print(18),输出：18

# 命名规范
1. 变量名只能是 字母、数字或下划线的任意组合
2. 变量名的第一个字符不能是数字
3. 关键字不能声明为变量名，常用关键字如下
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from','global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
年龄=18 # 强烈建议不要使用中文命名

3.3、变量名的命名风格

# 风格一：驼峰体
AgeOfTony = 56 
NumberOfStudents = 80
# 风格二：纯小写下划线(在python中，变量名的命名推荐使用该风格)
age_of_tony = 56 
number_of_students = 80

3.4、变量值的三大特性

#1、id
反应的是变量在内存中的唯一编号，内存地址不同id肯定不同#2、type
变量值的类型#3、value
变量值

三、常量

3.1、什么是常量？

常量指在程序运行过程中不会改变的量

3.2、为什么要有常量？

在程序运行过程中，有些值是固定的、不应该被改变，比如圆周率 3.141592653…

3.3、怎么使用常量？

在Python中没有一个专门的语法定义常量，约定俗成是用全部大写的变量名表示常量。如：PI=3.14159。所以单从语法层面去讲，常量的使用与变量完全一致。

4、Python语法入门之基本数据类型

一 引入

变量值也有不同的类型

salary = 3.1 # 用浮点型去记录薪资
age = 18 # 用整型去记录年龄
name = 'lili' # 用字符串类型去记录人名

二 数字类型

2.1 int整型

2.1.1 作用

用来记录人的年龄，出生年份，学生人数等整数相关的状态

2.1.2 定义

age=18birthday=1990student_count=48

2.2 float浮点型

2.2.1 作用

用来记录人的身高，体重，薪资等小数相关的状态

2.2.2 定义

height=172.3weight=103.5salary=15000.89

2.3 数字类型的使用

1 、数学运算

>>> a = 1
>>> b = 3
>>> c = a + b
>>> c
4

2、比较大小

>>> x = 10
>>> y = 11
>>> x > y
False

三 字符串类型str

3.1 作用

用来记录人的名字，家庭住址，性别等描述性质的状态

3.2 定义

name = 'harry'address = '上海市浦东新区'sex = '男'

用单引号、双引号、多引号，都可以定义字符串，本质上是没有区别的，但是

#1、需要考虑引号嵌套的配对问题
msg = "My name is Tony , I'm 18 years old!" #内层有单引号，外层就需要用双引号
#2、多引号可以写多行字符串
msg = '''天下只有两种人。比如一串葡萄到手，一种人挑最好的先吃，另一种人把最好的留到最后吃。照例第一种人应该乐观，因为他每吃一颗都是吃剩的葡萄里最好的；第二种人应该悲观，因为他每吃一颗都是吃剩的葡萄里最坏的。不过事实却适得其反，缘故是第二种人还有希望，第一种人只有回忆。'''

3.3 使用

数字可以进行加减乘除等运算，字符串呢？也可以，但只能进行"相加"和"相乘"运算。
>>> name = 'tony'
>>> age = '18'
>>> name + age #相加其实就是简单的字符串拼接
'tony18'
>>> name * 5 #相乘就相当于将字符串相加了5次
'tonytonytonytonytony'

四 列表list

4.1 作用

如果我们需要用一个变量记录多个学生的姓名，用数字类型是无法实现，字符串类型确实可以记录下来，比如

stu_names=‘张三 李四 王五’，但存的目的是为了取，此时若想取出第二个学生的姓名实现起来相当麻烦，而列表类型就是专门用来记录多个同种属性的值（比如同一个班级多个学生的姓名、同一个人的多个爱好等），并且存取都十分方便

4.2 定义

>>> stu_names=['张三','李四','王五']

4.3 使用

# 1、列表类型是用索引来对应值，索引代表的是数据的位置，从0开始计数
>>> stu_names=['张三','李四','王五']
>>> stu_names[0] 
'张三'
>>> stu_names[1]
'李四'
>>> stu_names[2]
'王五'
# 2、列表可以嵌套，嵌套取值如下
>>> students_info=[['tony',18,['jack',]],['jason',18,['play','sleep']]]
>>> students_info[0][2][0] #取出第一个学生的第一个爱好
'play'

五 字典dict

5.1 作用

如果我们需要用一个变量记录多个值，但多个值是不同属性的，比如人的姓名、年龄、身高，用列表可以存，但列表是用索引对应值的，而索引不能明确地表示值的含义，这就用到字典类型，字典类型是用key：value形式来存储数据，其中key可以对value有描述性的功能

5.2 定义

>>> person_info={'name':'tony','age':18,'height':185.3}

5.3 使用

# 1、字典类型是用key来对应值，key可以对值有描述性的功能，通常为字符串类型
>>> person_info={'name':'tony','age':18,'height':185.3}
>>> person_info['name']
'tony'
>>> person_info['age']
18
>>> person_info['height']
185.3
# 2、字典可以嵌套，嵌套取值如下
>>> students=[
... {'name':'tony','age':38,'hobbies':['play','sleep']},
... {'name':'jack','age':18,'hobbies':['read','sleep']},
... {'name':'rose','age':58,'hobbies':['music','read','sleep']},
... ]
>>> students[1]['hobbies'][1] #取第二个学生的第二个爱好
'sleep'

六 布尔bool

6.1 作用

用来记录真假这两种状态

6.2 定义

>>> is_ok = True
>>> is_ok = False

6.3 使用

通常用来当作判断的条件，我们将在if判断中用到它

5、Python语法入门之垃圾回收机制

一 引入

解释器在执行到定义变量的语法时，会申请内存空间来存放变量的值，而内存的容量是有限的，这就涉及到变量值所占用内存空间的回收问题，当一个变量值没有用了（简称垃圾）就应该将其占用的内存给回收掉，那什么样的变量值是没有用的呢？​ 单从逻辑层面分析，我们定义变量将变量值存起来的目的是为了以后取出来使用，而取得变量值需要通过其绑定的直接引用（如x=10，10被x直接引用）或间接引用（如l=[x,]，x=10，10被x直接引用，而被容器类型l间接引用），所以当一个变量值不再绑定任何引用时，我们就无法再访问到该变量值了，该变量值自然就是没有用的，就应该被当成一个垃圾回收。​ 毫无疑问，内存空间的申请与回收都是非常耗费精力的事情，而且存在很大的危险性，稍有不慎就有可能引发内存溢出问题，好在Cpython解释器提供了自动的垃圾回收机制来帮我们解决了这件事。

二、什么是垃圾回收机制？

垃圾回收机制（简称GC）是Python解释器自带一种机，专门用来回收不可用的变量值所占用的内存空间

三、为什么要用垃圾回收机制？

程序运行过程中会申请大量的内存空间，而对于一些无用的内存空间如果不及时清理的话会导致内存使用殆尽（内存溢出），导致程序崩溃，因此管理内存是一件重要且繁杂的事情，而python解释器自带的垃圾回收机制把程序员从繁杂的内存管理中解放出来。

四、理解GC原理需要储备的知识

4.1、堆区与栈区

在定义变量时，变量名与变量值都是需要存储的，分别对应内存中的两块区域：堆区与栈区

# 1、变量名与值内存地址的关联关系存放于栈区# 2、变量值存放于堆区，内存管理回收的则是堆区的内容，

4.2 直接引用与间接引用

直接引用指的是从栈区出发直接引用到的内存地址。

间接引用指的是从栈区出发引用到堆区后，再通过进一步引用才能到达的内存地址。

如

l2 = [20, 30]  # 列表本身被变量名l2直接引用，包含的元素被列表间接引用
x = 10  # 值10被变量名x直接引用
l1 = [x, l2]  # 列表本身被变量名l1直接引用，包含的元素被列表间接引用

五、垃圾回收机制原理分析

Python的GC模块主要运用了“引用计数”（reference counting）来跟踪和回收垃圾。在引用计数的基础上，还可以通过“标记-清除”（mark and sweep）解决容器对象可能产生的循环引用的问题，并且通过“分代回收”（generation collection）以空间换取时间的方式来进一步提高垃圾回收的效率。

5.1、引用计数

引用计数就是：变量值被变量名关联的次数

如：age=18

变量值18被关联了一个变量名age，称之为引用计数为1

引用计数增加：

age=18 （此时，变量值18的引用计数为1）

m=age （把age的内存地址给了m，此时，m,age都关联了18，所以变量值18的引用计数为2）

引用计数减少：

age=10（名字age先与值18解除关联，再与3建立了关联，变量值18的引用计数为1）

del m（del的意思是解除变量名x与变量值18的关联关系，此时，变量18的引用计数为0）

值18的引用计数一旦变为0，其占用的内存地址就应该被解释器的垃圾回收机制回收

5.2、引用计数的问题与解决方案

5.2.1 问题一：循环引用

引用计数机制存在着一个致命的弱点，即循环引用（也称交叉引用）

# 如下我们定义了两个列表，简称列表1与列表2，变量名l1指向列表1，变量名l2指向列表2
>>> l1=['xxx']  # 列表1被引用一次，列表1的引用计数变为1   
>>> l2=['yyy']  # 列表2被引用一次，列表2的引用计数变为1   
>>> l1.append(l2)             # 把列表2追加到l1中作为第二个元素，列表2的引用计数变为2
>>> l2.append(l1)             # 把列表1追加到l2中作为第二个元素，列表1的引用计数变为2# l1与l2之间有相互引用
# l1 = ['xxx'的内存地址,列表2的内存地址]
# l2 = ['yyy'的内存地址,列表1的内存地址]
>>> l1
['xxx', ['yyy', [...]]]
>>> l2
['yyy', ['xxx', [...]]]
>>> l1[1][1][0]
'xxx'

python引入了“标记-清除” 与“分代回收”来分别解决引用计数的循环引用与效率低的问题

5.2.2 解决方案：标记-清除

容器对象（比如：list，set，dict，class，instance）都可以包含对其他对象的引用，所以都可能产生循环引用。而“标记-清除”计数就是为了解决循环引用的问题。

标记/清除算法的做法是当应用程序可用的内存空间被耗尽的时，就会停止整个程序，然后进行两项工作，第一项则是标记，第二项则是清除

5.2.3 问题二：效率问题

基于引用计数的回收机制，每次回收内存，都需要把所有对象的引用计数都遍历一遍，这是非常消耗时间的，于是引入了分代回收来提高回收效率，分代回收采用的是用“空间换时间”的策略。

5.2.4 解决方案：分代回收

代：

分代回收的核心思想是：在历经多次扫描的情况下，都没有被回收的变量，gc机制就会认为，该变量是常用变量，gc对其扫描的频率会降低，具体实现原理如下：

分代指的是根据存活时间来为变量划分不同等级（也就是不同的代）新定义的变量，放到新生代这个等级中，假设每隔1分钟扫描新生代一次，如果发现变量依然被引用，那么该对象的权重（权重本质就是个整数）加一，当变量的权重大于某个设定得值（假设为3），会将它移动到更高一级的青春代，青春代的gc扫描的频率低于新生代（扫描时间间隔更长），假设5分钟扫描青春代一次，这样每次gc需要扫描的变量的总个数就变少了，节省了扫描的总时间，接下来，青春代中的对象，也会以同样的方式被移动到老年代中。也就是等级（代）越高，被垃圾回收机制扫描的频率越低

回收：

回收依然是使用引用计数作为回收的依据

虽然分代回收可以起到提升效率的效果，但也存在一定的缺点：

例如一个变量刚刚从新生代移入青春代，该变量的绑定关系就解除了，该变量应该被回收，但青春代的扫描频率低于新生代，这就到导致了应该被回收的垃圾没有得到及时地清理。没有十全十美的方案：
毫无疑问，如果没有分代回收，即引用计数机制一直不停地对所有变量进行全体扫描，可以更及时地清理掉垃圾占用的内存，但这种一直不停地对所有变量进行全体扫描的方式效率极低，所以我们只能将二者中和。综上
垃圾回收机制是在清理垃圾&释放内存的大背景下，允许分代回收以极小部分垃圾不会被及时释放为代价，以此换取引用计数整体扫描频率的降低，从而提升其性能，这是一种以空间换时间的解决方案目录

6、Python语法入门之与用户交互、运算符

一 程序与用户交互

1.1、什么是与用户交互

用户交互就是人往计算机中input/输入数据，计算机print/输出结果

1.2、为什么要与用户交互？

为了让计算机能够像人一样与用户沟通交流

1.3、如何与用户交互

交互的本质就是输入、输出

1.3.1 输入input:

# 在python3中input功能会等待用户的输入，用户输入任何内容，都存成字符串类型，然后赋值给等号左边的变量名
>>> username=input('请输入您的用户名：') 
请输入您的用户名：jack # username = "jack"
>>> password=input('请输入您的密码：') 
请输入您的密码：123 # password = "123"# 了解知识：
# 1、在python2中存在一个raw_input功能与python3中的input功能一模一样
# 2、在python2中还存在一个input功能，需要用户输入一个明确的数据类型，输入什么类型就存成什么类型
>>> l=input('输入什么类型就存成什么类型: ')
输入什么类型就存成什么类型: [1,2,3]
>>> type(l)
<type 'list'>

1.3.2 输出print:

>>> print('hello world')  # 只输出一个值
hello world
>>> print('first','second','third')  # 一次性输出多个值，值用逗号隔开
first second third# 默认print功能有一个end参数，该参数的默认值为"\n"(代表换行)，可以将end参数的值改成任意其它字符
print("aaaa",end='')
print("bbbb",end='&')
print("cccc",end='@')
#整体输出结果为：aaaabbbb&cccc@

1.3.3 输出之格式化输出

(1)什么是格式化输出？

把一段字符串里面的某些内容替换掉之后再输出，就是格式化输出。

(2)为什么要格式化输出？

我们经常会输出具有某种固定格式的内容，比如：'亲爱的xxx你好！你xxx月的话费是xxx，余额是xxx‘，我们需要做的就是将xxx替换为具体的内容。

(3)如何格式化输出？

这就用到了占位符，如：%s、%d：

# %s占位符：可以接收任意类型的值
# %d占位符：只能接收数字
>>> print('亲爱的%s你好！你%s月的话费是%d，余额是%d' %('tony',12,103,11))
亲爱的tony你好！你12月的话费是103，余额是11# 练习1：接收用户输入，打印成指定格式
name = input('your name: ')
age = input('your age: ') #用户输入18,会存成字符串18,无法传给%d
print('My name is %s,my age is %s' %(name,age))# 练习2：用户输入姓名、年龄、工作、爱好 ，然后打印成以下格式
------------ info of Tony -----------
Name  : Tony
Age   : 22
Sex   : male
Job   : Teacher 
------------- end -----------------

二 基本运算符

2.1 算术运算符

python支持的算数运算符与数学上计算的符号使用是一致的，我们以x=9，y=2为例来依次介绍它们

2.2 比较运算符

比较运算用来对两个值进行比较，返回的是布尔值True或False，我们以x=9，y=2为例来依次介绍它们

2.3 赋值运算符

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

2.3.1 增量赋值

2.3.2 链式赋值

如果我们想把同一个值同时赋值给多个变量名，可以这么做

>>> z=10
>>> y=z
>>> x=y
>>> x,y,z
(10, 10, 10)

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

>>> x=y=z=10
>>> x,y,z
(10, 10, 10)

2.3.3 交叉赋值

我们定义两个变量m与n

如果我们想将m与n的值交换过来，可以这么做

>>> temp=m
>>> m=n
>>> n=temp
>>> m,n
(20, 10)

交叉赋值指的是一行代码可以搞定这件事

>>> m=10
>>> n=20
>>> m,n=n,m # 交叉赋值
>>> m,n
(20, 10)

2.3.4 解压赋值

如果我们想把列表中的多个值取出来依次赋值给多个变量名，可以这么做

>>> nums=[11,22,33,44,55]
>>> 
>>> a=nums[0]
>>> b=nums[1]
>>> c=nums[2]
>>> d=nums[3]
>>> e=nums[4]
>>> a,b,c,d,e
(11, 22, 33, 44, 55)

解压赋值指的是一行代码可以搞定这件事

>>> a,b,c,d,e=nums # nums包含多个值，就好比一个压缩包，解压赋值因此得名
>>> a,b,c,d,e
(11, 22, 33, 44, 55)

注意，上述解压赋值，等号左边的变量名个数必须与右面包含值的个数相同,否则会报错

#1、变量名少了
>>> a,b=nums
Traceback (most recent call last):File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)#2、变量名多了
>>> a,b,c,d,e,f=nums
Traceback (most recent call last):File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 6, got 5)

但如果我们只想取头尾的几个值，可以用*_匹配

>>> a,b,*_=nums
>>> a,b
(11, 22)

ps：字符串、字典、元组、集合类型都支持解压赋值

2.4 逻辑运算符

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

2.4.1 连续多个and

可以用and连接多个条件，会按照从左到右的顺序依次判断，一旦某一个条件为False，则无需再往右判断，可以立即判定最终结果就为False，只有在所有条件的结果都为True的情况下，最终结果才为True。

>>> 2 > 1 and 1 != 1 and True and 3 > 2 # 判断完第二个条件，就立即结束，得的最终结果为False
False

2.4.2 连续多个or

可以用or连接多个条件，会按照从左到右的顺序依次判断，一旦某一个条件为True，则无需再往右判断，可以立即判定最终结果就为True，只有在所有条件的结果都为False的情况下，最终结果才为False

>>> 2 > 1 or 1 != 1 or True or 3 > 2 # 判断完第一个条件，就立即结束，得的最终结果为True
True

2.4.3 优先级not>and>or

#1、三者的优先级关系：not>and>or，同一优先级默认从左往右计算。
>>> 3>4 and 4>3 or 1==3 and 'x' == 'x' or 3 >3
False#2、最好使用括号来区别优先级，其实意义与上面的一样
'''
原理为：
(1) not的优先级最高，就是把紧跟其后的那个条件结果取反，所以not与紧跟其后的条件不可分割(2) 如果语句中全部是用and连接，或者全部用or连接，那么按照从左到右的顺序依次计算即可(3) 如果语句中既有and也有or，那么先用括号把and的左右两个条件给括起来，然后再进行运算
'''
>>> (3>4 and 4>3) or (1==3 and 'x' == 'x') or 3 >3
False #3、短路运算：逻辑运算的结果一旦可以确定，那么就以当前处计算到的值作为最终结果返回
>>> 10 and 0 or '' and 0 or 'abc' or 'egon' == 'dsb' and 333 or 10 > 4
我们用括号来明确一下优先级
>>> (10 and 0) or ('' and 0) or 'abc' or ('egon' == 'dsb' and 333) or 10 > 4
短路：       0      ''            'abc'                    假     假              真返回：                            'abc'#4、短路运算面试题：
>>> 1 or 3
1
>>> 1 and 3
3
>>> 0 and 2 and 1
0
>>> 0 and 2 or 1
1
>>> 0 and 2 or 1 or 4
1
>>> 0 or False and 1
False 

2.5 成员运算符

注意：虽然下述两种判断可以达到相同的效果，但我们推荐使用第二种格式，因为not in语义更加明确

>>> not 'lili' in ['jack','tom','robin']
True
>>> 'lili' not in ['jack','tom','robin']
True

2.6 身份运算符

需要强调的是：==双等号比较的是value是否相等，而is比较的是id是否相等

#1. id相同，内存地址必定相同，意味着type和value必定相同
#2. value相同type肯定相同，但id可能不同,如下
>>> x='Info Tony:18'
>>> y='Info Tony:18'
>>> id(x),id(y) # x与y的id不同，但是二者的值相同
(4327422640, 4327422256)>>> x == y # 等号比较的是value
True
>>> type(x),type(y) # 值相同type肯定相同
(<class 'str'>, <class 'str'>)
>>> x is y # is比较的是id，x与y的值相等但id可以不同
False

7、Python语法入门之流程控制

一 引子：

流程控制即控制流程，具体指控制程序的执行流程，而程序的执行流程分为三种结构：顺序结构（之前我们写的代码都是顺序结构）、分支结构（用到if判断）、循环结构（用到while与for）

二 分支结构

2.1 什么是分支结构

分支结构就是根据条件判断的真假去执行不同分支对应的子代码

2.2 为什么要用分支结构

人类某些时候需要根据条件来决定做什么事情，比如：如果今天下雨，就带伞

所以程序中必须有相应的机制来控制计算机具备人的这种判断能力

2.3 如何使用分支结构

2.3.1 if语法

用if关键字来实现分支结构，完整语法如下

if 条件1:   # 如果条件1的结果为True，就依次执行：代码1、代码2，......代码1代码2......
elif 条件2: # 如果条件2的结果为True，就依次执行：代码3、代码4，......代码3代码4......
elif 条件3: # 如果条件3的结果为True，就依次执行：代码5、代码6，......代码5代码6......
else:　　   # 其它情况，就依次执行：代码7、代码8，......代码7代码8......
# 注意：
# 1、python用相同缩进(4个空格表示一个缩进)来标识一组代码块，同一组代码会自上而下依次运行
# 2、条件可以是任意表达式，但执行结果必须为布尔类型# 在if判断中所有的数据类型也都会自动转换成布尔类型# 2.1、None，0，空（空字符串，空列表，空字典等）三种情况下转换成的布尔值为False# 2.2、其余均为True

2.3.2 if应用案例

案例1：

如果：女人的年龄>30岁，那么：叫阿姨

age_of_girl=31
if age_of_girl > 30:print('阿姨好')

案例2：

如果：女人的年龄>30岁，那么：叫阿姨，否则：叫小姐

age_of_girl=18
if age_of_girl > 30:print('阿姨好')
else:print('小姐好')

案例3：

如果：女人的年龄>=18并且<22岁并且身高>170并且体重<100并且是漂亮的，那么：表白，否则：叫阿姨**

age_of_girl=18
height=171
weight=99
is_pretty=True
if age_of_girl >= 18 and age_of_girl < 22 and height > 170 and weight < 100 and is_pretty == True:print('表白...')
else:print('阿姨好')

案例4：

如果：成绩>=90，那么：优秀

如果成绩>=80且<90,那么：良好

如果成绩>=70且<80,那么：普通

其他情况：很差

score=input('>>: ')
score=int(score)if score >= 90:print('优秀')
elif score >= 80:print('良好')
elif score >= 70:print('普通')
else:print('很差')

案例 5：if 嵌套

#在表白的基础上继续：
#如果表白成功，那么：在一起
#否则：打印。。。age_of_girl=18
height=171
weight=99
is_pretty=True
success=Falseif age_of_girl >= 18 and age_of_girl < 22 and height > 170 and weight < 100 and is_pretty == True:if success:print('表白成功,在一起')else:print('什么爱情不爱情的,爱nmlgb的爱情,爱nmlg啊...')
else:print('阿姨好')

练习1: 登陆功能

name=input('请输入用户名字：').strip()
password=input('请输入密码：').strip()
if name == 'tony' and password == '123':print('tony login success')
else:print('用户名或密码错误')

练习2：

#!/usr/bin/env python
#根据用户输入内容打印其权限'''
egon --> 超级管理员
tom  --> 普通管理员
jack,rain --> 业务主管
其他 --> 普通用户
'''
name=input('请输入用户名字：')if name == 'egon':print('超级管理员')
elif name == 'tom':print('普通管理员')
elif name == 'jack' or name == 'rain':print('业务主管')
else:print('普通用户')

三 循环结构

3.1 什么是循环结构

循环结构就是重复执行某段代码块

3.2 为什么要用循环结构

人类某些时候需要重复做某件事情

所以程序中必须有相应的机制来控制计算机具备人的这种循环做事的能力

3.3 如何使用循环结构

3.3.1 while循环语法

python中有while与for两种循环机制，其中while循环称之为条件循环，语法如下

while 条件:代码1     代码2     代码3
while的运行步骤：
步骤1：如果条件为真，那么依次执行：代码1、代码2、代码3、......
步骤2：执行完毕后再次判断条件,如果条件为True则再次执行：代码1、代码2、代码3、......，如果条件为False,则循环终止

3.3.2 while循环应用案例

案例一：while循环的基本使用

用户认证程序

#用户认证程序的基本逻辑就是接收用户输入的用户名密码然后与程序中存放的用户名密码进行判断，判断成功则登陆成功，判断失败则输出账号或密码错误
username = "jason"
password = "123"inp_name =  input("请输入用户名：")
inp_pwd =  input("请输入密码：")
if inp_name == username and inp_pwd == password:print("登陆成功")
else:print("输入的用户名或密码错误！")
#通常认证失败的情况下，会要求用户重新输入用户名和密码进行验证，如果我们想给用户三次试错机会，本质就是将上述代码重复运行三遍，你总不会想着把代码复制3次吧。。。。
username = "jason"
password = "123"# 第一次验证
inp_name =  input("请输入用户名：")
inp_pwd =  input("请输入密码：")
if inp_name == username and inp_pwd == password:print("登陆成功")
else:print("输入的用户名或密码错误！")# 第二次验证
inp_name =  input("请输入用户名：")
inp_pwd =  input("请输入密码：")
if inp_name == username and inp_pwd == password:print("登陆成功")
else:print("输入的用户名或密码错误！")# 第三次验证
inp_name =  input("请输入用户名：")
inp_pwd =  input("请输入密码：")
if inp_name == username and inp_pwd == password:print("登陆成功")
else:print("输入的用户名或密码错误！")#即使是小白的你，也觉得的太low了是不是，以后要修改功能还得修改3次，因此记住，写重复的代码是程序员最不耻的行为。
#那么如何做到不用写重复代码又能让程序重复一段代码多次呢？ 循环语句就派上用场啦（使用while循环实现）username = "jason"
password = "123"
# 记录错误验证的次数
count = 0
while count < 3:inp_name = input("请输入用户名：")inp_pwd = input("请输入密码：")if inp_name == username and inp_pwd == password:print("登陆成功")else:print("输入的用户名或密码错误！")count += 1

案例二：while+break的使用

使用了while循环后，代码确实精简多了，但问题是用户输入正确的用户名密码以后无法结束循环，那如何结束掉一个循环呢？这就需要用到break了！

username = "jason"
password = "123"
# 记录错误验证的次数
count = 0
while count < 3:inp_name = input("请输入用户名：")inp_pwd = input("请输入密码：")if inp_name == username and inp_pwd == password:print("登陆成功")break # 用于结束本层循环else:print("输入的用户名或密码错误！")count += 1

案例三：while循环嵌套+break

如果while循环嵌套了很多层，要想退出每一层循环则需要在每一层循环都有一个break

username = "jason"
password = "123"
count = 0
while count < 3:  # 第一层循环inp_name = input("请输入用户名：")inp_pwd = input("请输入密码：")if inp_name == username and inp_pwd == password:print("登陆成功")while True:  # 第二层循环cmd = input('>>: ')if cmd == 'quit':break  # 用于结束本层循环，即第二层循环print('run <%s>' % cmd)break  # 用于结束本层循环，即第一层循环else:print("输入的用户名或密码错误！")count += 1

案例四：while循环嵌套+tag的使用

针对嵌套多层的while循环，如果我们的目的很明确就是要在某一层直接退出所有层的循环，其实有一个窍门，就让所有while循环的条件都用同一个变量，该变量的初始值为True，一旦在某一层将该变量的值改成False，则所有层的循环都结束

username = "jason"
password = "123"
count = 0tag = True
while tag: inp_name = input("请输入用户名：")inp_pwd = input("请输入密码：")if inp_name == username and inp_pwd == password:print("登陆成功")while tag:  cmd = input('>>: ')if cmd == 'quit':tag = False  # tag变为False， 所有while循环的条件都变为False breakprint('run <%s>' % cmd)break  # 用于结束本层循环，即第一层循环else:print("输入的用户名或密码错误！")count += 1

案例五：while+continue的使用

break代表结束本层循环，而continue则用于结束本次循环，直接进入下一次循环

# 打印1到10之间，除7以外的所有数字
number=11
while number>1:number -= 1if number==7:continue # 结束掉本次循环，即本次循环continue之后的代码都不会运行了，而是直接进入下一次循环print(number)

案例五：while+else的使用

在while循环的后面，我们可以跟else语句，当while 循环正常执行完并且中间没有被break 中止的话，就会执行else后面的语句，所以我们可以用else来验证，循环是否正常结束

count = 0
while count <= 5 :count += 1print("Loop",count)
else:print("循环正常执行完啦")
print("-----out of while loop ------")
输出
Loop 1
Loop 2
Loop 3
Loop 4
Loop 5
Loop 6
循环正常执行完啦   #没有被break打断，所以执行了该行代码
-----out of while loop ------

如果执行过程中被break，就不会执行else的语句

count = 0
while count <= 5 :count += 1if count == 3:breakprint("Loop",count)
else:print("循环正常执行完啦")
print("-----out of while loop ------")
输出
Loop 1
Loop 2
-----out of while loop ------ #由于循环被break打断了，所以不执行else后的输出语句

练习1：

寻找1到100之间数字7最大的倍数（结果是98）

number = 100
while number > 0:if number %7 == 0:print(number)breaknumber -= 1

练习2：

age=18
count=0
while count<3:count+=1guess = int(input(">>:"))if guess > age :print("猜的太大了，往小里试试...")elif guess < age :print("猜的太小了，往大里试试...")else:print("恭喜你，猜对了...")

3.3.3 for循环语法

循环结构的第二种实现方式是for循环，for循环可以做的事情while循环都可以实现，之所以用for循环是因为在循环取值（即遍历值）时for循环比while循环的使用更为简洁，

for循环语法如下

for 变量名 in 可迭代对象: # 此时只需知道可迭代对象可以是字符串\列表\字典，我们之后会专门讲解可迭代对象代码一代码二...#例1
for item in ['a','b','c']:print(item)
# 运行结果
a
b
c# 参照例1来介绍for循环的运行步骤
# 步骤1：从列表['a','b','c']中读出第一个值赋值给item（item=‘a’），然后执行循环体代码
# 步骤2：从列表['a','b','c']中读出第二个值赋值给item（item=‘b’），然后执行循环体代码
# 步骤3: 重复以上过程直到列表中的值读尽

3.3.4 for循环应用案例

# 简单版：for循环的实现方式
for count in range(6):  # range(6)会产生从0-5这6个数print(count)# 复杂版：while循环的实现方式
count = 0
while count < 6:print(count)count += 1

案例二：遍历字典

# 简单版：for循环的实现方式
for k in {'name':'jason','age':18,'gender':'male'}:  # for 循环默认取的是字典的key赋值给变量名kprint(k)# 复杂版：while循环确实可以遍历字典，后续将会迭代器部分详细介绍

案例三：for循环嵌套

#请用for循环嵌套的方式打印如下图形：
*****
*****
*****for i in range(3):for j in range(5):print("*",end='')print()  # print()表示换行

注意：break 与 continue也可以用于for循环，使用语法同while循环

练习一：

打印九九乘法表

for i in range(1,10):for j in range(1,i+1):print('%s*%s=%s' %(i,j,i*j),end=' ')print()

练习二：

打印金字塔

# 分析
'''
#max_level=5*        # current_level=1，空格数=4，*号数=1***       # current_level=2,空格数=3,*号数=3*****      # current_level=3,空格数=2,*号数=5*******     # current_level=4,空格数=1,*号数=7*********    # current_level=5,空格数=0,*号数=9# 数学表达式
空格数=max_level-current_level
*号数=2*current_level-1
'''
# 实现：
max_level=5
for current_level in range(1,max_level+1):for i in range(max_level-current_level):print(' ',end='') #在一行中连续打印多个空格for j in range(2*current_level-1):print('*',end='') #在一行中连续打印多个空格print()

8、基本数据类型及内置方法

一 引子

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

二 数字类型int与float

2.1 定义

# 1、定义：
# 1.1 整型int的定义
age=10  # 本质age = int(10)# 1.2 浮点型float的定义
salary=3000.3  # 本质salary=float(3000.3)# 注意：名字+括号的意思就是调用某个功能，比如
# print(...)调用打印功能
# int(...)调用创建整型数据的功能
# float(...)调用创建浮点型数据的功能

2.2 类型转换

# 1、数据类型转换
# 1.1 int可以将由纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错
>>> s = '123'
>>> res = int(s)
>>> res,type(res)
(123, <class 'int'>)>>> int('12.3') # 错误演示：字符串内包含了非整数符号.
Traceback (most recent call last):File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '12.3'# 1.2 进制转换
# 十进制转其他进制
>>> bin(3)
'0b11'
>>> oct(9)
'0o11'
>>> hex(17)
'0x11'
# 其他进制转十进制
>>> int('0b11',2)
3
>>> int('0o11',8)
9
>>> int('0x11',16)
17# 1.3 float同样可以用来做数据类型的转换
>>> s = '12.3'
>>> res=float(s)
>>> res,type(res)
(12.3, <class 'float'>)

2.3 使用

数字类型主要就是用来做数学运算与比较运算，因此数字类型除了与运算符结合使用之外，并无需要掌握的内置方法

三 字符串

3.1 定义：

# 定义：在单引号\双引号\三引号内包含一串字符
name1 = 'jason'  # 本质:name = str('任意形式内容')
name2 = "lili"  # 本质:name = str("任意形式内容")
name3 = """ricky"""  # 本质:name = str("""任意形式内容""")

3.2 类型转换

# 数据类型转换：str()可以将任意数据类型转换成字符串类型，例如 
>>> type(str([1,2,3])) # list->str
<class 'str'>
>>> type(str({"name":"jason","age":18})) # dict->str
<class 'str'>
>>> type(str((1,2,3)))  # tuple->str
<class 'str'>
>>> type(str({1,2,3,4})) # set->str
<class 'str'>

3.3 使用

3.3.1 优先掌握的操作

>>> str1 = 'hello python!'# 1.按索引取值(正向取，反向取)：
# 1.1 正向取(从左往右)
>>> str1[6]
p
# 1.2 反向取(负号表示从右往左)
>>> str1[-4]
h
# 1.3 对于str来说，只能按照索引取值，不能改
>>> str1[0]='H' # 报错TypeError# 2.切片(顾头不顾尾，步长)
# 2.1 顾头不顾尾：取出索引为0到8的所有字符
>>> str1[0:9]  
hello pyt
# 2.2 步长：0:9:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2、4、6、8的字符
>>> str1[0:9:2]  
hlopt 
# 2.3 反向切片
>>> str1[::-1]  # -1表示从右往左依次取值
!nohtyp olleh# 3.长度len
# 3.1 获取字符串的长度，即字符的个数，但凡存在于引号内的都算作字符)
>>> len(str1) # 空格也算字符
13# 4.成员运算 in 和 not in    
# 4.1 int:判断hello 是否在 str1里面
>>> 'hello' in str1  
True
# 4.2 not in:判断tony 是否不在 str1里面
>>> 'tony' not in str1 
True# 5.strip移除字符串首尾指定的字符(默认移除空格)
# 5.1 括号内不指定字符，默认移除首尾空白字符(空格、\n、\t)
>>> str1 = '  life is short!  '
>>> str1.strip()  
life is short!# 5.2 括号内指定字符，移除首尾指定的字符
>>> str2 = '**tony**'  
>>> str2.strip('*')  
tony# 6.切分split
# 6.1 括号内不指定字符，默认以空格作为切分符号
>>> str3='hello world'
>>> str3.split()
['hello', 'world']
# 6.2 括号内指定分隔字符，则按照括号内指定的字符切割字符串
>>> str4 = '127.0.0.1'
>>> str4.split('.')  
['127', '0', '0', '1']  # 注意:split切割得到的结果是列表数据类型# 7.循环
>>> str5 = '今天你好吗？'
>>> for line in str5:  # 依次取出字符串中每一个字符
...     print(line)
...
今
天
你
好
吗
？

3.3.2 需要掌握的操作

1. strip, lstrip, rstrip

>>> str1 = '**tony***'>>> str1.strip('*')  # 移除左右两边的指定字符
'tony'
>>> str1.lstrip('*')  # 只移除左边的指定字符
tony***
>>> str1.rstrip('*')  # 只移除右边的指定字符
**tony

2. lower(),upper()

>>> str2 = 'My nAme is tonY！'>>> str2.lower()  # 将英文字符串全部变小写
my name is tony！
>>> str2.upper()  # 将英文字符串全部变大写
MY NAME IS TONY！

3. startswith,endswith

>>> str3 = 'tony jam'# startswith()判断字符串是否以括号内指定的字符开头，结果为布尔值True或False
>>> str3.startswith('t') 
True
>>> str3.startswith('j')
False
# endswith()判断字符串是否以括号内指定的字符结尾，结果为布尔值True或False
>>> str3.endswith('jam')
True
>>> str3.endswith('tony')  
False

4.格式化输出之format

之前我们使用%s来做字符串的格式化输出操作，在传值时，必须严格按照位置与%s一一对应，而字符串的内置方法format则提供了一种不依赖位置的传值方式

案例：

# format括号内在传参数时完全可以打乱顺序，但仍然能指名道姓地为指定的参数传值，name=‘tony’就是传给{name}
>>> str4 = 'my name is {name}, my age is {age}!'.format(age=18,name='tony')
>>> str4  
'my name is tony, my age is 18!'>>> str4 = 'my name is {name}{name}{name}, my age is {name}!'.format(name='tony', age=18)
>>> str4  
'my name is tonytonytony, my age is tony!'

format的其他使用方式（了解）

# 类似于%s的用法，传入的值会按照位置与{}一一对应
>>> str4 = 'my name is {}, my age is {}!'.format('tony', 18)
>>> str4 
my name is tony, my age is 18!
# 把format传入的多个值当作一个列表，然后用{索引}取值
>>> str4 = 'my name is {0}, my age is {1}!'.format('tony', 18)
>>> str4
my name is tony, my age is 18!>>> str4 = 'my name is {1}, my age is {0}!'.format('tony', 18)
>>> str4  
my name is 18, my age is tony!>>> str4 = 'my name is {1}, my age is {1}!'.format('tony', 18)
>>> str4  
my name is 18, my age is 18!

5.split,rsplit

# split会按照从左到右的顺序对字符串进行切分，可以指定切割次数
>>> str5='C:/a/b/c/d.txt'
>>> str5.split('/',1)
['C:', 'a/b/c/d.txt']  # rsplit刚好与split相反，从右往左切割，可以指定切割次数
>>> str5='a|b|c'
>>> str5.rsplit('|',1)
['a|b', 'c']

6. join

# 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
>>> '%'.join('hello') # 从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接
'h%e%l%l%o'
>>> '|'.join(['tony','18','read'])  # 从列表中取出多个字符串，然后按照*作为分隔符号进行拼接
'tony|18|read'

7. replace

# 用新的字符替换字符串中旧的字符
>>> str7 = 'my name is tony, my age is 18!'  # 将tony的年龄由18岁改成73岁
>>> str7 = str7.replace('18', '73')  # 语法:replace('旧内容', '新内容')
>>> str7
my name is tony, my age is 73!# 可以指定修改的个数
>>> str7 = 'my name is tony, my age is 18!'
>>> str7 = str7.replace('my', 'MY',1) # 只把一个my改为MY
>>> str7
'MY name is tony, my age is 18!'

8.isdigit

# 判断字符串是否是纯数字组成，返回结果为True或False
>>> str8 = '5201314'
>>> str8.isdigit()
True>>> str8 = '123g123'
>>> str8.isdigit()
False

3.3.3 了解操作

# 1.find,rfind,index,rindex,count
# 1.1 find：从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1
>>> msg='tony say hello'
>>> msg.find('o',1,3)  # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引
1  
# 1.2 index:同find,但在找不到时会报错
>>> msg.index('e',2,4) # 报错ValueError
# 1.3 rfind与rindex：略
# 1.4 count:统计字符串在大字符串中出现的次数
>>> msg = "hello everyone"
>>> msg.count('e')  # 统计字符串e出现的次数
4
>>> msg.count('e',1,6)  # 字符串e在索引1~5范围内出现的次数
1# 2.center,ljust,rjust,zfill
>>> name='tony'
>>> name.center(30,'-')  # 总宽度为30，字符串居中显示，不够用-填充
-------------tony-------------
>>> name.ljust(30,'*')  # 总宽度为30，字符串左对齐显示，不够用*填充
tony**************************
>>> name.rjust(30,'*')  # 总宽度为30，字符串右对齐显示，不够用*填充
**************************tony
>>> name.zfill(50)  # 总宽度为50，字符串右对齐显示，不够用0填充
0000000000000000000000000000000000000000000000tony# 3.expandtabs
>>> name = 'tony\thello'  # \t表示制表符(tab键)
>>> name
tony    hello
>>> name.expandtabs(1)  # 修改\t制表符代表的空格数
tony hello# 4.captalize,swapcase,title
# 4.1 captalize：首字母大写
>>> message = 'hello everyone nice to meet you!'
>>> message.capitalize()
Hello everyone nice to meet you!  
# 4.2 swapcase：大小写翻转
>>> message1 = 'Hi girl, I want make friends with you!'
>>> message1.swapcase()  
hI GIRL, i WANT MAKE FRIENDS WITH YOU!  
#4.3 title：每个单词的首字母大写
>>> msg = 'dear my friend i miss you very much'
>>> msg.title()
Dear My Friend I Miss You Very Much # 5.is数字系列
#在python3中
num1 = b'4' #bytes
num2 = u'4' #unicode,python3中无需加u就是unicode
num3 = '四' #中文数字
num4 = 'Ⅳ' #罗马数字#isdigt:bytes,unicode
>>> num1.isdigit()
True
>>> num2.isdigit()
True
>>> num3.isdigit()
False
>>> num4.isdigit() 
False#isdecimal:uncicode(bytes类型无isdecimal方法)
>>> num2.isdecimal() 
True
>>> num3.isdecimal() 
False
>>> num4.isdecimal() 
False#isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)
>>> num2.isnumeric() 
True
>>> num3.isnumeric() 
True
>>> num4.isnumeric() 
True# 三者不能判断浮点数
>>> num5 = '4.3'
>>> num5.isdigit()
False
>>> num5.isdecimal()
False
>>> num5.isnumeric()
False'''
总结:最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景如果要判断中文数字或罗马数字,则需要用到isnumeric。
'''# 6.is其他
>>> name = 'tony123'
>>> name.isalnum() #字符串中既可以包含数字也可以包含字母
True
>>> name.isalpha() #字符串中只包含字母
False
>>> name.isidentifier()
True
>>> name.islower()  # 字符串是否是纯小写
True
>>> name.isupper()  # 字符串是否是纯大写
False
>>> name.isspace()  # 字符串是否全是空格
False
>>> name.istitle()  # 字符串中的单词首字母是否都是大写
False

四 列表

4.1 定义

# 定义：在[]内,用逗号分隔开多个任意数据类型的值
l1 = [1,'a',[1,2]]  # 本质:l1 = list([1,'a',[1,2]])

4.2 类型转换

# 但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中
>>> list('wdad') # 结果：['w', 'd', 'a', 'd'] 
>>> list([1,2,3]) # 结果：[1, 2, 3]
>>> list({"name":"jason","age":18}) #结果：['name', 'age']
>>> list((1,2,3)) # 结果：[1, 2, 3] 
>>> list({1,2,3,4}) # 结果：[1, 2, 3, 4]

4.3 使用

4.3.1 优先掌握的操作

# 1.按索引存取值(正向存取+反向存取)：即可存也可以取  
# 1.1 正向取(从左往右)
>>> my_friends=['tony','jason','tom',4,5]
>>> my_friends[0]  
tony
# 1.2 反向取(负号表示从右往左)
>>> my_friends[-1]  
5
# 1.3 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错
>>> my_friends = ['tony','jack','jason',4,5]
>>> my_friends[1] = 'martthow'
>>> my_friends
['tony', 'martthow', 'jason', 4, 5]# 2.切片(顾头不顾尾，步长)
# 2.1 顾头不顾尾：取出索引为0到3的元素
>>> my_friends[0:4] 
['tony', 'jason', 'tom', 4]
# 2.2 步长：0:4:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素
>>> my_friends[0:4:2]  
['tony', 'tom']# 3.长度
>>> len(my_friends)
5# 4.成员运算in和not in
>>> 'tony' in my_friends
True
>>> 'xxx' not in my_friends
True# 5.添加
# 5.1 append()列表尾部追加元素
>>> l1 = ['a','b','c']
>>> l1.append('d')
>>> l1
['a', 'b', 'c', 'd']# 5.2 extend()一次性在列表尾部添加多个元素
>>> l1.extend(['a','b','c'])
>>> l1
['a', 'b', 'c', 'd', 'a', 'b', 'c']# 5.3 insert()在指定位置插入元素
>>> l1.insert(0,"first")  # 0表示按索引位置插值
>>> l1
['first', 'a', 'b', 'c', 'alisa', 'a', 'b', 'c']# 6.删除
# 6.1 del
>>> l = [11,22,33,44]
>>> del l[2]  # 删除索引为2的元素
>>> l
[11,22,44]# 6.2 pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
>>> l = [11,22,33,22,44]
>>> res=l.pop()
>>> res
44
>>> res=l.pop(1)
>>> res
22# 6.3 remove()括号内指名道姓表示要删除哪个元素，没有返回值
>>> l = [11,22,33,22,44]
>>> res=l.remove(22) # 从左往右查找第一个括号内需要删除的元素
>>> print(res)
None# 7.reverse()颠倒列表内元素顺序
>>> l = [11,22,33,44]
>>> l.reverse() 
>>> l
[44,33,22,11]# 8.sort()给列表内所有元素排序
# 8.1 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
>>> l = [11,22,3,42,7,55]
>>> l.sort()
>>> l 
[3, 7, 11, 22, 42, 55]  # 默认从小到大排序
>>> l = [11,22,3,42,7,55]
>>> l.sort(reverse=True)  # reverse用来指定是否跌倒排序，默认为False
>>> l 
[55, 42, 22, 11, 7, 3]
# 8.2 了解知识：
# 我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如
>>> l1=[1,2,3]
>>> l2=[2,]
>>> l2 > l1
True
# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
>>> s1='abc'
>>> s2='az'
>>> s2 > s1 # s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立
True
# 所以我们也可以对下面这个列表排序
>>> l = ['A','z','adjk','hello','hea']
>>> l.sort()
>>> l
['A', 'adjk', 'hea', 'hello','z']# 9.循环
# 循环遍历my_friends列表里面的值
for line in my_friends:print(line) 
'tony'
'jack'
'jason'
4
5

4.3.2 了解操作

>>> l=[1,2,3,4,5,6]
>>> l[0:3:1] 
[1, 2, 3]  # 正向步长
>>> l[2::-1] 
[3, 2, 1]  # 反向步长# 通过索引取值实现列表翻转
>>> l[::-1]
[6, 5, 4, 3, 2, 1]

五 元组

5.1 作用

元组与列表类似，也是可以存多个任意类型的元素，不同之处在于元组的元素不能修改，即元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取

5.2 定义方式

# 在()内用逗号分隔开多个任意类型的值
>>> countries = ("中国"，"美国"，"英国")  # 本质:countries = tuple("中国"，"美国"，"英国")
# 强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组
>>> countries = ("中国"，)  # 本质:countries = tuple("中国")

5.3 类型转换

# 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
>>> tuple('wdad') # 结果：('w', 'd', 'a', 'd') 
>>> tuple([1,2,3]) # 结果：(1, 2, 3)
>>> tuple({"name":"jason","age":18}) # 结果：('name', 'age')
>>> tuple((1,2,3)) # 结果：(1, 2, 3)
>>> tuple({1,2,3,4}) # 结果：(1, 2, 3, 4)
# tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

5.4 使用

>>> tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33) 
# 1、按索引取值(正向取+反向取)：只能取，不能改否则报错！  
>>> tuple1[0]
1
>>> tuple1[-2]
22
>>> tuple1[0] = 'hehe'  # 报错：TypeError:# 2、切片(顾头不顾尾，步长)
>>> tuple1[0:6:2] 
(1, 15000.0, 22)# 3、长度
>>> len(tuple1)  
6# 4、成员运算 in 和 not in
>>> 'hhaha' in tuple1 
True
>>> 'hhaha' not in tuple1  
False # 5、循环
>>> for line in tuple1:
...     print(line)
1
hhaha
15000.0
11
22
33

六 字典

6.1 定义方式

# 定义：在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型，详见第八小节，通常key应该是str类型，因为str类型会对value有描述性的功能
info={'name':'tony','age':18,'sex':'male'} #本质info=dict({....})
# 也可以这么定义字典
info=dict(name='tony',age=18,sex='male') # info={'age': 18, 'sex': 'male', 'name': 'tony'}

6.2 类型转换

# 转换1: 
>>> info=dict([['name','tony'],('age',18)])
>>> info
{'age': 18, 'name': 'tony'}# 转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
>>> {}.fromkeys(('name','age','sex'),None)  
{'age': None, 'sex': None, 'name': None}

6.3 使用

6.3.1 优先掌握的操作

# 1、按key存取值：可存可取
# 1.1 取
>>> dic = {
...     'name': 'xxx',
...     'age': 18,
...     'hobbies': ['play game', 'basketball']
... }
>>> dic['name']
'xxx'
>>> dic['hobbies'][1]
'basketball'
# 1.2 对于赋值操作，如果key原先不存在于字典，则会新增key:value
>>> dic['gender'] = 'male'  
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}
# 1.3 对于赋值操作，如果key原先存在于字典，则会修改对应value的值
>>> dic['name'] = 'tony'
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}# 2、长度len
>>> len(dic) 
3# 3、成员运算in和not in
>>> 'name' in dic  # 判断某个值是否是字典的key
True# 4、删除
>>> dic.pop('name')  # 通过指定字典的key来删除字典的键值对
>>> dic
{'age': 18, 'hobbies': ['play game', 'basketball']}# 5、键keys()，值values()，键值对items()
>>> dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}
# 获取字典所有的key
>>> dic.keys()  
dict_keys(['name', 'age', 'hobbies'])
# 获取字典所有的value
>>> dic.values()
dict_values(['xxx', 18, ['play game', 'basketball']])
# 获取字典所有的键值对
>>> dic.items()
dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])# 6、循环
# 6.1 默认遍历的是字典的key
>>> for key in dic:
...     print(key)
... 
age
hobbies
name
# 6.2 只遍历key
>>> for key in dic.keys():
...     print(key)
... 
age
hobbies
name
# 6.3 只遍历value
>>> for key in dic.values():
...     print(key)
... 
18
['play game', 'basketball']
xxx
# 6.4 遍历key与value
>>> for key in dic.items():
...     print(key)
... 
('age', 18)
('hobbies', ['play game', 'basketball'])
('name', 'xxx')

6.3.2 需要掌握的操作

1. get()

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.get('k1')
'jason'  # key存在，则获取key对应的value值
>>> res=dic.get('xxx') # key不存在，不会报错而是默认返回None
>>> print(res)
None  
>>> res=dic.get('xxx',666) # key不存在时，可以设置默认返回的值
>>> print(res)
666 
# ps:字典取值建议使用get方法

2. pop()

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> v = dic.pop('k2')  # 删除指定的key对应的键值对,并返回值
>>> dic
{'k1': 'jason', 'kk2': 'JY'}
>>> v
'Tony'

3. popitem()

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> item = dic.popitem()  # 随机删除一组键值对,并将删除的键值放到元组内返回
>>> dic
{'k3': 'JY', 'k2': 'Tony'}
>>> item
('k1', 'jason')

4. update()

# 用新字典更新旧字典，有则修改，无则添加
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.update({'k1':'JN','k4':'xxx'})
>>> dic
{'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}

5. fromkeys()

>>> dic = dict.fromkeys(['k1','k2','k3'],[])
>>> dic
{'k1': [], 'k2': [], 'k3': []}

6. setdefault()

# key不存在则新增键值对，并将新增的value返回
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k3',333)
>>> res
333
>>> dic # 字典中新增了键值对
{'k1': 111, 'k3': 333, 'k2': 222}# key存在则不做任何修改，并返回已存在key对应的value值
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k1',666)
>>> res
111
>>> dic # 字典不变
{'k1': 111, 'k2': 222}

七 集合

7.1 作用

集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算

7.2 定义

"""
定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：1：每个元素必须是不可变类型2：集合内没有重复的元素3：集合内元素无序
"""
s = {1,2,3,4}  # 本质 s = set({1,2,3,4})# 注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者?
d = {} # 默认是空字典 
s = set() # 这才是定义空集合

7.3 类型转换

# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
>>> s = set([1,2,3,4])
>>> s1 = set((1,2,3,4))
>>> s2 = set({'name':'jason',})
>>> s3 = set('egon')
>>> s,s1,s2,s3
{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}

7.4 使用

7.4.1 关系运算

我们定义两个集合friends与friends2来分别存放两个人的好友名字，然后以这两个集合为例讲解集合的关系运算

>>> friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们 
>>> friends2 = {"Jy","ricky","jason","egon"}   # 用户2的好友们

两个集合的关系如下图所示

# 1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）
>>> friends1 | friends2
{'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}# 2.交集(&)：求两个用户的共同好友
>>> friends1 & friends2
{'jason', 'egon'}# 3.差集(-)：
>>> friends1 - friends2 # 求用户1独有的好友
{'kevin', 'zero'}
>>> friends2 - friends1 # 求用户2独有的好友
{'ricky', 'Jy'}# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
>>> friends1 ^ friends2
{'kevin', 'zero', 'ricky', 'Jy'}# 5.值是否相等(==)
>>> friends1 == friends2
False# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} >= {1,2}
True
# 6.2 不存在包含关系，则返回False
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False# 7.子集
>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True

7.4.2 去重

集合去重复有局限性

# 1. 只能针对不可变类型
# 2. 集合本身是无序的，去重之后无法保留原来的顺序

示例如下

>>> l=['a','b',1,'a','a']
>>> s=set(l)
>>> s # 将列表转成了集合
{'b', 'a', 1}
>>> l_new=list(s) # 再将集合转回列表
>>> l_new
['b', 'a', 1] # 去除了重复，但是打乱了顺序# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
l=[{'name':'lili','age':18,'sex':'male'},{'name':'jack','age':73,'sex':'male'},{'name':'tom','age':20,'sex':'female'},{'name':'lili','age':18,'sex':'male'},{'name':'lili','age':18,'sex':'male'},
]new_l=[]for dic in l:if dic not in new_l:new_l.append(dic)print(new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
[{'age': 18, 'sex': 'male', 'name': 'lili'}, {'age': 73, 'sex': 'male', 'name': 'jack'}, {'age': 20, 'sex': 'female', 'name': 'tom'}
]

7.4.3 其他操作

# 1.长度
>>> s={'a','b','c'}
>>> len(s)
3# 2.成员运算
>>> 'c' in s
True# 3.循环
>>> for item in s:
...     print(item)
... 
c
a
b

7.5 练习

"""
一.关系运算有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合pythons={'jason','egon','kevin','ricky','gangdan','biubiu'}linuxs={'kermit','tony','gangdan'}1. 求出即报名python又报名linux课程的学员名字集合2. 求出所有报名的学生名字集合3. 求出只报名python课程的学员名字4. 求出没有同时这两门课程的学员名字集合
"""
# 求出即报名python又报名linux课程的学员名字集合
>>> pythons & linuxs
# 求出所有报名的学生名字集合
>>> pythons | linuxs
# 求出只报名python课程的学员名字
>>> pythons - linuxs
# 求出没有同时这两门课程的学员名字集合
>>> pythons ^ linuxs

八 可变类型与不可变类型

**可变数据类型：**值发生改变时，内存地址不变，即id不变，证明在改变原值

**不可变类型：**值发生改变时，内存地址也发生改变，即id也变，证明是没有在改变原值，是产生了新的值

数字类型:

>>> x = 10
>>> id(x)
1830448896 
>>> x = 20
>>> id(x)
1830448928
# 内存地址改变了，说明整型是不可变数据类型，浮点型也一样

字符串

>>> x = "Jy"
>>> id(x)
938809263920 
>>> x = "Ricky"
>>> id(x)
938809264088
# 内存地址改变了，说明字符串是不可变数据类型

列表

>>> list1 = ['tom','jack','egon']
>>> id(list1)
486316639176
>>> list1[2] = 'kevin'
>>> id(list1)
486316639176
>>> list1.append('lili')
>>> id(list1)
486316639176
# 对列表的值进行操作时，值改变但内存地址不变，所以列表是可变数据类型

元组

>>> t1 = ("tom","jack",[1,2])
>>> t1[0]='TOM' # 报错：TypeError
>>> t1.append('lili') # 报错：TypeError
# 元组内的元素无法修改，指的是元组内索引指向的内存地址不能被修改
>>> t1 = ("tom","jack",[1,2])
>>> id(t1[0]),id(t1[1]),id(t1[2])
(4327403152, 4327403072, 4327422472)
>>> t1[2][0]=111 # 如果元组中存在可变类型，是可以修改，但是修改后的内存地址不变
>>> t1
('tom', 'jack', [111, 2])
>>> id(t1[0]),id(t1[1]),id(t1[2]) # 查看id仍然不变
(4327403152, 4327403072, 4327422472)

字典

>>> dic = {'name':'egon','sex':'male','age':18}
>>> 
>>> id(dic)
4327423112
>>> dic['age']=19
>>> dic
{'age': 19, 'sex': 'male', 'name': 'egon'}
>>> id(dic)
4327423112
# 对字典进行操作时，值改变的情况下，字典的id也是不变，即字典也是可变数据类型

九 数据类型总结

1、数字类型：
2、字符串类型
3、列表类型
4、元组类型
5、字典类型
6、集合类型

',‘age’:73,‘sex’:‘male’},
{‘name’:‘tom’,‘age’:20,‘sex’:‘female’},
{‘name’:‘lili’,‘age’:18,‘sex’:‘male’},
{‘name’:‘lili’,‘age’:18,‘sex’:‘male’},
]

new_l=[]

for dic in l:
if dic not in new_l:
new_l.append(dic)

print(new_l)

结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重

[
{‘age’: 18, ‘sex’: ‘male’, ‘name’: ‘lili’},
{‘age’: 73, ‘sex’: ‘male’, ‘name’: ‘jack’},
{‘age’: 20, ‘sex’: ‘female’, ‘name’: ‘tom’}
]

### 7.4.3 其他操作```python
# 1.长度
>>> s={'a','b','c'}
>>> len(s)
3# 2.成员运算
>>> 'c' in s
True# 3.循环
>>> for item in s:
...     print(item)
... 
c
a
b

7.5 练习

"""
一.关系运算有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合pythons={'jason','egon','kevin','ricky','gangdan','biubiu'}linuxs={'kermit','tony','gangdan'}1. 求出即报名python又报名linux课程的学员名字集合2. 求出所有报名的学生名字集合3. 求出只报名python课程的学员名字4. 求出没有同时这两门课程的学员名字集合
"""
# 求出即报名python又报名linux课程的学员名字集合
>>> pythons & linuxs
# 求出所有报名的学生名字集合
>>> pythons | linuxs
# 求出只报名python课程的学员名字
>>> pythons - linuxs
# 求出没有同时这两门课程的学员名字集合
>>> pythons ^ linuxs

八 可变类型与不可变类型

**可变数据类型：**值发生改变时，内存地址不变，即id不变，证明在改变原值

**不可变类型：**值发生改变时，内存地址也发生改变，即id也变，证明是没有在改变原值，是产生了新的值

数字类型:

>>> x = 10
>>> id(x)
1830448896 
>>> x = 20
>>> id(x)
1830448928
# 内存地址改变了，说明整型是不可变数据类型，浮点型也一样

[外链图片转存中…(img-tFqCXMEe-1591518506013)]

字符串

>>> x = "Jy"
>>> id(x)
938809263920 
>>> x = "Ricky"
>>> id(x)
938809264088
# 内存地址改变了，说明字符串是不可变数据类型

[外链图片转存中…(img-RxG2CT3N-1591518506014)]

列表

>>> list1 = ['tom','jack','egon']
>>> id(list1)
486316639176
>>> list1[2] = 'kevin'
>>> id(list1)
486316639176
>>> list1.append('lili')
>>> id(list1)
486316639176
# 对列表的值进行操作时，值改变但内存地址不变，所以列表是可变数据类型

[外链图片转存中…(img-09sBZFjD-1591518506015)]

元组

>>> t1 = ("tom","jack",[1,2])
>>> t1[0]='TOM' # 报错：TypeError
>>> t1.append('lili') # 报错：TypeError
# 元组内的元素无法修改，指的是元组内索引指向的内存地址不能被修改
>>> t1 = ("tom","jack",[1,2])
>>> id(t1[0]),id(t1[1]),id(t1[2])
(4327403152, 4327403072, 4327422472)
>>> t1[2][0]=111 # 如果元组中存在可变类型，是可以修改，但是修改后的内存地址不变
>>> t1
('tom', 'jack', [111, 2])
>>> id(t1[0]),id(t1[1]),id(t1[2]) # 查看id仍然不变
(4327403152, 4327403072, 4327422472)

[外链图片转存中…(img-7lZK6ehv-1591518506016)]

字典

>>> dic = {'name':'egon','sex':'male','age':18}
>>> 
>>> id(dic)
4327423112
>>> dic['age']=19
>>> dic
{'age': 19, 'sex': 'male', 'name': 'egon'}
>>> id(dic)
4327423112
# 对字典进行操作时，值改变的情况下，字典的id也是不变，即字典也是可变数据类型

[外链图片转存中…(img-zHZ9Kj43-1591518506017)]

九 数据类型总结

[外链图片转存中…(img-WvuuT9Ax-1591518506018)]

1、数字类型：
2、字符串类型
3、列表类型
4、元组类型
5、字典类型
6、集合类型