1. 计算机基础

硬件
- 主板
- CPU
- I/O设备
- 内存RAM
软件
- 操作系统
  - Windows
  - Linux
  - Unix
- 应用软件

终端工具

- 打开方法
    - 点击图标
    - 搜索命令终端
- 退出终端
    - 1.exit<回车>
    - 2. ctrl + d

2.Linux 的使用

2.1 Linux/Unix 命令

命令名 [选项] [参数]
- 注：[]的内容代表可选
命令示例
- ls # 显示当前文件夹下所有的文件和文件夹
- ls -s # 列表显示所有文件
- pwd # 显示当前位置在哪文件夹下
- cd / # 切换到跟文件夹
- cd # 切换到用户主目录
路径
- 是用来记录一个文件或文件夹的字符串
- 如
  - /home/songpengyuan
  - /home/songpengyuan/a.txt
  - 根（root） /
路径分为两种：
- 绝对路径
  - 以 / 开头的路径为绝对路径
  - 在任何时候，一个文件的绝对路径都是唯一的
- 相对路径
  1. 文件/文件夹名称
  2. . 当前文件夹
  3. .. 上一级文件夹
  4. ~ 用户主目录（家目录）
    - 根据登录的用名去定位
ls 命令
- 作用：显示文件或文件夹内容
- 格式：
  - ls [选项] [文件夹名或文件名]
- 常用选项：
  - -l 列表显示文件的详细信息
  - -a 显示全部文件/文件夹
cd 命令 (change dir)
- 作用：改变当前工作路径(进入某个目录)
- 格式： cd [路径]
- 示例
  - cd /home/songpengyuan
  - cd /
  - cd
  - cd ..
  - cd ~
  - cd - # 切换到进入这个文件夹之前的文件夹
mkdir 命令
- 作用：创建一个或多个文件夹
- 格式： mkdir 文件夹名1 文件夹名2
- 示例：
  - mkdir a b c d
  - mkdir -p a/bb/ccc/ddd
- 常用选项：
  - -p 如果是中间的文件夹不存在，则逐级创建所有的文件夹
rmdir 命令：
- 作用：删除一个或多个文件夹（文件）
- 格式： rmdir [选项] 文件夹名
- 常用选项：
  - -p 如果中间文件夹也不为空，则逐级删除中间文件夹
  - 示例
    - rmdir a b c d
    - rmdir -p a/bb/ccc/dddd
tree 命令：
- 作用：显示目录树
- 示例：
  - tree
  - tree day 001
touch 命令
- 作用：
  1. 创建新的文件
  2. 如果文件已经存在，则更新文件的修改时间
- 格式：
  - touch 文件路径
- 示例：
  - touch newfile
  - touch lodfile
rm 命令（remove）
- 作用：删除文件或者文件夹
- 格式
  - rm [选项] 文件/文件夹
- 示例：
  - rm a.txt b.txt
  - rm c.txt
  - rm *.txt
  - rm -r a
- 常用选项：
  - -r 递归删除文件夹内的文件和文件夹
  - -i 删除前给出提示（y代表yes,n代表no）
  - -f 强制删除，不给任何提示
操作特殊符号的路径的方法
- 用两个双引号（""）把路径括起来
- 例：
  - mkdir 'a b'
  - rmdir 'a b' help 选项：
- 查看此命令的帮助信息
- 格式：
  - 命令名 -- help
- 示例
  - ls --help
man 命令帮助
- 格式：
  - man Linux/UNIX命令名
- 作用
  - 查看命令所有对应的帮助文档（手册）
- 示例：
  - man ls
  - man rm
- 翻页：上下键
- 退出： q键
快捷键
- Tab 补全命令和路径
- 上下键翻出以前操作过的命令
cat 命令
- 作用：将文件内容作为标准输出打印到终端
- 格式： cat 文件名1 文件名2
- 例：
  - cat ../day01/day01.txt
more 命令
- 作用：分页显示文本的文件内容
- 格式：more 文件名
- 示例：
  - more ../day01/day01.txt
- 基本操作
  - q 退出
  - 空格下翻一页
通配符
- - 匹配0个，1个或多个任意字符
- ? 匹配1个任意字符
- 示例：
  - touch a ab ac abc aabb bc cd
  - ls a?
  - ls a*
  - ls ?c
  - ls a*b
  - rm *v
cp 命令
- 作用：复制文件或文件夹
- 格式：
  - cp [选项] 源文件或文件夹目标文件或文件夹
- 示例：
  - cp ../day01/day01.txt ~/
  - #在复制的过程中修改名称
    - cp ../day01/day01.txt ~/day01.txt.bak
- 常用选项
  - -a 复制文件夹中的全部内容
mv 命令
- 作用：文件搬移或更名
- 格式： mv 源文件或文件夹目录文件或文件夹
- 示例
  - mv passwd mypw # 改名字
  - mv passwd ~/ # 移动文件
find 命令
- 作用：根据文件名等信息查找指定的文件
- 格式
  - find 路径 -name "文件名"
- 示例：
  - 查找用户主目录下有哪些文件以.txt 结尾
    - find ~ -name "*.txt"
grep 命令
- 作用：查找文件中相应的内容，及文本信息
- 格式：
  - grep "内容" [选项] 文件名或路径
- 常用选项
  - -n 显示行号
  - -r/-R 递归搜索文件夹内的文件
- 示例：
  - grep "文件" *.txt
  - grep "命令" -n "*.txt" # 显示行号
  - grep "root" -nr /etc
压缩/解压缩命令
- gzip 命令
  - 作用：用gzip压缩算法对文件进行压缩，生成压缩后的文件
  - 格式：
    - gzip 文件名
  - .gz 为用gzip压缩后的文件
- gunzip 命令
  - 作用：用gzip压缩果的文件进行解压
  - 格式：
    - zunzip 文件名
  - 示例：
    - cp /etc/passwd ~/
    - gzip ~/passwd
    - ls -l ~/passwd.gz
    - gunzip ~/passwd.gz
    - ls -l ~/passwd.gz
tar 命令
- 作用：
  - 对文件或文件夹进行打包和解包的操作
- 格式：
  - tar [选项] 文件名 [文件名或路径]
- 常用选项
  - -c #创建包
  - -x #解包
  - -v #显示操作的文件细节
  - -z #用gzip/gunzip对包进行压缩和解压缩
  - -f 文件名 #正在操作的文件名
  - -c 路径 #改变解压缩路径（只对解包有用）
- 示例：
  - #将linux/day01打包并压缩为day01.tar.gz
    - tar -czvf day01.tar.gz linux/day01
  - #将 day01.tar.gz 解包
    - cd ~/
    - tar -xzvf aid1805/day.tar.gz
sudo 命令
- 作用：用超级用户权限来执行这些命令
- 格式：
  - sudo 命令 [选项] [参数]
- 常用选项
  - -i 切换到 root 用户
- 例
  - sudo mkdir /mytest
  - sudo -i
  - rmdir /mytest
exit 命令
- 退出用户登陆
文件权限的管理路径
- 查看文件权限
  - ls -l
- 文件类型
  - d 文件夹
  - - 普通文件
  - l 链接文件
  - c/b 设备文件
- 文件权限：
  - r 读权限
  - w 写权限
  - x 执行权限
- 权限分组
  - 用户权限(user) 组权限（group）其他权限（other）
- 最高权限
  - rwx rwx rwx
- 最低权限
- 属主：owner
- 属组：group
chmod 命令
- 作用：修改文件权限
- 格式
  - chmod 权限文件名/文件夹名
- 权限：
  - u 用户(属主)
  - g 同组用户
  - o 其他用户
  - a 所有用户
  - - 添加权限
  - - 删除权限
- 示例：
  - chmod u+r a.txt
  - chmod o-rwx a.txt
  - chmod g+rw a.txt
输出重定向
- 输出分两种：
  - 1. 标准输出
  - 1. 标注错误输出
- 标准输出重定向
  - ">"将一个命令的标准输出重定向到指定文件
  - ">>"将一个命令的标准输出重定向"追加"到指定文件
- 标准错误输出重定向
  - "2>"将一个命令的标准"错误"输出重定向到指定文件
  - "2>>"将一个命令的标准"错误"输出重定向"追加"到指定文件
- 重定向所有输出
  - "&>"
  - "&>>"

2. <<python语言开发>>

2.1 python 简介

创始人： Guido van Rossum(荷兰人)
时间： 1989 圣诞节期间
Python的命令：源于一个喜剧团 Monty Python
www.tiobe.com 编程语言排名

2.2 python 的应用领域

系统运维
网络编程
科学计算
人工智能，机器人
web开发
大数据及数据库编程
云计算
教育
游戏，图像
其他

2.3 python 的优缺点

优点
- 面向对象（Java, C++, python）
- 免费
- 可移植
- 可混合编程（C/C++/Java/.net）
- 简单易学易用
- 应用领域广
- 开发效率高
- 开源
缺点
- 与C/C++ 相比执行速度不够快
- 不能封闭源代码

2.4 python官网

2.5 python版本

python v2.7 (2020年结束维护)
python v3.5 (当前教学版本)
python v3.8 (最新版本)

2.6 python 安装

windows / Mac OS X / Unix ...

2.7 python 的运行

python 的运行
- python 的解释执行器
- CPython(python3)
- Jython
- IronPython
- PyPy
第一个python 程序
- 见：hello.py
python 的运行
- 方法1
  - python3 hello.py
- 方法2
  - 在hello.py的第一行写入: #! /usr/bin/python3
  - chmod u+x hello.py
  - ./hello.pyh
python 的交互模式
- $ python3
- 退出
  - quit()
  - exit()
  - ctrl + D
python 的注释
- #号开头，直到行尾
- 作用：让注释内容不参加解释执行
python 的核心数据类型
- 数字（整数，浮点数，复数，布尔型）
- 字符串
- 列表等
解释执行器
- python3 （C语言开发，CPython的一种）
- python 的文件后缀 .py
运行两种模式
- 执行模式
  - python3 XXX.py
- 交互模式
  - python3 <回车>
数字类型
- 整型数 int
  - -100， 100， 0， 999999
  - 0b1001
  - 0o1234567
  - 0x1a2b3c
- 浮点型数 float
  - 3.14, 0.314el
- 复数 complex
  - 1+2j
- 布尔型数 bool
  - True False
None 空值
运算符
- +, -, *, /, //, %, **
- () 分组表达式
变量
- 变量名必须标识符
  - 标识符的正则表达式：[A-Za-z_][A-Za-z0-9_]*
- 变量名不能是关键字
  - True, False, None, is, not, del,...
赋值语句
- 变量名 = 表达式
  - x = 100
- 变量名1 = 变量名2 = 变量名3 = ... = 表达式
  - x = y = z = 100
- 变量名1, 变量名2, 变量名3 = 序列（序列赋值）
  - x,y,z = 100,200,300
del 语句删除变量
引用计数 refrence count
is / is not 运算符
id(obj) 返回一个对象的地址
input('提示语')
小整数对象池
- -5 ~ 256
复合赋值运算
- += -= *= /= //= %= **=
- 变量名 += 表达式

比较运算符

运算符
- '<'
- '<='
- '>'
- '>='
- '=='
- '!='
语法：
- 左表达式 < 右表达式
说明：比较运算返回布尔类型的值

示例

    20 < 100 # True
    300 >= 20 # True
    1 == 2 # False
    x = 70
    y = 70
    x != y # False
    0 <= x <= 100 # Ture

数值对象的构造（创建）函数
- float(obj)
  - 用字符串或数字转换为浮点数，如果不给出实参，则返回0.0
- int(x=0, base=10)
  - 用数字或字符串转换为整数，如果不给出实参则返回0
  - base 进制, base must be >= 2 and <= 36
- complex(r=0.0, i=0.0)
  - 用数字创建一个复数
- bool(x)
  - 用x创建一个布尔值（True/False)
函数调用表达式
- 函数名（传参列表）
- 说明：函数调用表达式，此表达式一定会返回一个对象的引用关系。如果不需要返回值，通常返回None对象的引用关系
- bool(obj) 返回假值的情况：
  - None 空值
  - Flase 假值
  - 0， 0.0， 0j 所有的数字零
  - '' 空字符串
  - [] 空列表
  - {} 空字典
  - () 空元祖
内建数值型函数
- abs(x) 去x的绝对值
- round(number, ndigits=0)
  - 对数值进行"四舍五入",ndigits是小数向右取整的位数，负数表示向左取整
- pow(x, y, z=None)
  - 相当于 x ** y 或 x ** y % z
help() 函数查看帮助
- help(函数名或对象名)
语句 statements
- 语句由一些表达式组成，通常一条语句可以独立执行来完成一部分事情并形成结果
- python 建议一条语句写在一行内
- 多条语句写在一行内需要用分号(;) 分开
- 示例：
```
   print("hello")
   x = 100 + 200
   print(x)
   # 写在一行内为：
   print("hello");x = 100 + 200; print(x)
```
- 显式换行：
  - 折行符 \ (读作反斜杠)
    - 折行符必须放在一行的末尾，来示意解释执行器下一行也是本行的语句
  - 示例：
```
    x = 100 + (200 * 300) \
    + 400 - 500 + 600
    print(x)
```
- 隐式折行
  - 所有的括号的内容换行，成为隐式换行
  - 括号包括() [] {}
  - 示例：
```
    x = 100 + (200 
    * 300) + 400 - 500 + 600
    print(x)
```

if 语句

作用：主程序根据选择性的执行某条语句或某些语句

语法：

    if 真值表达式1：
        语句块
    elif 真值表达式2：
        语句块2
    elif 真值表达式3：
        语句块3
    ...
    else:
        语句块

说明： elif 可以有0个，1个或多个 else 可以有0个或1个

if 语句的真值表达式

    if 100：
        print('真值')
    # 等同于：
    if (bool(100)):
        print('真值')

if 语句真值表达式返回的对象要用bool(x) 取值后再决定执行哪条语句

if 语句的嵌套
- if 语句本身是有多条语句组成的一条复合语句
- if 语句可以作为语句嵌套到另一个语句的内部
条件表达式
- 语法：
  - 表达式1 if 真值表达式 else 表达式2
- 作用：
  - 根据真值表达式的取值（True/False）来决定执行表达式1或表达式2，并返回结果
pass 语句
- 作用：通常用来填充语法空白, pass 又名空语句
- 语法： pass
布尔运算
- 运算符： not, and, or
- 布尔非操作： not
  - 语法： not x
  - 作用：
    - 对表达式x进行布尔取非，如bool(x)
    - 为Ture 则返回False, 否则返回True
  - 示例
```
    not True # 返回 False
    not False # 返回 True
```
- 布尔与操作: and
  - 语法： x and y
    - 注：x, y 代表表达式
  - 作用
    - 优先返回假值对象
    - 当x的布尔值为False时，返回x,否则返回y
- 布尔或操作： or
  - 语法：x or
  - 作用：
    - 优先返回真值对象
    - 当x 为 True时返回x,否则返回y
正负号运算符
- '+ (正号)'
- '- (负号)'
- 语法
  - + 表达式
  - - 表达式
- 说明：这是一元运算符(只有一个数据参加运算)
- 示例:
```
    a = 5
    b = -a # -5
    c = +a # 5
```

2.8 字符串 str

作用：用来记录文本（文字）信息
在非注释中，凡是用引号括起来的部分就是字符串
- ' 单引号
- " 双引号
- ''' 三单引号
- """ 三双引号
空字符串的字面值表示方法
```
    ''
    ""
    ''''''
    """"""
```

非空字符串的表示方法

    'hello'
    "world"
    '''hello'''
    """world"""

单引和双引号的区别：
- 单引号内的双引号不算结束符
- 双引号内的单引号不算结束符
三引号字符串的作用
- 三引号字符串中的换行会自动转换为换行符
- 三引号内可以包括单引号和双引号
隐式字符串的拼接
- s = "I'm a teacher!" 'My name is "songpengyuan"'
用转义序列代表特殊字符
- 字符串字面值中，用字符反斜杠（\）后面跟一些字符串代表特殊的一个字符
反斜杠转义字符表：
- ' 单引号
- " 双引号
- \ 一个反斜杠
- \n 换行
- \r 返回光标行首
- \t 水平制表符
- \v 垂直制表符
- \f 换页
- \b 倒退
- \0 空字符，字符为0
- \xXX XX 为两位十六进制表示的字符
- \uXXX XXXX为四个十六进制表示的Unicode16字符
- \UXXXXXXXX 八个十六进制表示的Unicode32字符
ASCII编码
- 记录128个英文字符对应的编码
- 用八个位表示文字，最高位一定为0，低7位表示数值
- ASXCII字符表:
  - $ man ascii <回车>
- 常用的ASCII字符编码
  
  字符十进制十六进制
  
  '0' 48 0x30
  
  'A' 65 0x41
  
  'a' 97 0x61
Unicode
- 记录65536个文字(包含英文的128个ASCII)
- 统一编码：分为Unicode16 和 Unicode32
序列的概念
- 字符串就是序列
- 序列的长度
  - len(x) # 返回字符串字符的个数
raw字符串（原始字符串）
- 格式：
  - r'字符串内容'
  - r"字符串内容"
  - r'''字符串内容'''
  - r"""字符串内容"""
- 作用：让转义符号 \ 无效
- 示例：
  - s = 'C:\newfile\test.py'
  - s = r'C:\newfile\test.py'
字符串的运算
- - 加号运算符用于拼接字符串
- - 运算度用于生成重复的字符串
- 注：字符串只能和整数相乘
- +=， *= 运算符，与其他赋合赋值运算符规则相同
in / not in 运算符
- 作用：
  - 用于判断某个字符串是否在
  - 相当前字符出现过。如果出现过返回True,否则返回False
- 语法：对象 in 字符串
- 示例：
```
    s = "welcome to here"
    'to' in s # True
    'songpengyuan' in s # False
```

字符	十进制	十六进制
'0'	48	0x30
'A'	65	0x41
'a'	97	0x61

字符串的比较运算

运算符：> >= < <= == !=
规则：依次按编码值进行比较，直到最短的字符结束为止
示例

    'A' < 'B' # True
    'ABC' > 'ABB' # True
    'ABC' > 'ACB' # False
    'ABC' == 'abc' # False
    'ABCD' != 'DCBA' # True

字符串的索引操作
- python 的字符串是不可以改变的字符序列
- 索引 index
  - 语法：字符串[整数表达式]
  - 说明
    - python 序列都可以用索引来访问序列中的对象
    - python 序列的正向索引是多0开始的
    - 第二个索引为1，最后一个索引len(s)为-1
    - python 序列的反向索引是从 -1开始的，-1代表最后一个，-2代表倒数第二个，第一个就是-len(s)
  - 示例
```
    s = 'ABCDE'
    print(s[0]) # A
    print(s[-1]) # E
```
切片 slice
- 作用：
  - 从一个字符串序列中取出相应的元素重新自成一格字符串序列
- 语法：
  - 字符串序列[(开始索引b):(结束索引e)(:(步长s))]
  - 注：小括号（）括其部分代表可省略
- 说明：
  1. 开始索引是切片开始切下的位置，0代表第一个元素，1代表第二个元素，-1代表最后一个
  2. 结束索引的切片的终止索引（但不包括终止点）
  3. 步长是切片每次获取完当前元素后移动的方向和偏移量
    1. 没有步长没相当于取值完成后向右移动一个索引的位置（默认为1）
    2. 当步长为正数时，取正向切片；
      - 步长默认为1，开始索引默认为0，结束索引默认为len(s);
      - 步长代表一下次索引的取值的增长值
    3. 当步长为负整数时，取反向切片
      - 默认的起始位置是最后一个元素，终止位置是第一个元素的前一个位置
- 示例
```
    s = 'ABCDE'
    a = s[1:4] # "BCD"
    
    a = s[3:5] # "DE"
    a = s[3:] # "DE"
    
    a = s[:3] # "ABC"
    a = s[0:3] # "ABC"
    
    a = s[1:1] # ""
    a = s.slice[4:1] # ""
    
    a = s[0:5:2] # "ACE"
    a = s[1::2] # "BD"
    a = s[::2] # "ACE"
    
    a = s[::-1] # "EDCBA"
    a = s[::-1] # "ECA"
    a = s[4:0:-2] # "EC"
```
- 资料地址
python3常用于序列的函数
- 序列的
  - len(x) 返回序列的长度
  - max(x) 返回序列的最大值元素
  - min(x) 返回序列的最小值元素
- 字符串编码转换函数
  - ord(c) 返回一个字符的Unicode值
  - chr(i) 返回i这个整数值所对应的字符
- 示例:
```
    s = "hello world"
    len(s) # 5
    max(s) # 'o'
    min(s) # 'e'
```
整数转字符串的函数
- bin(i) 将整数转换为二进制的字符串
- oct(i) 将整数转换为八进制的字符串
- hex(i) 将整数转换未十六进制的字符串

字符串的构造函数

str(obj='') 将对象转换为字符串
示例

    '123' + 456 # 出错，不合法
    str(True) # 'True'
    str(None) # 'None'
    str(3.14) # '3.14'

常用的字符串方法 Method

语法：对象.方法名(方法传参)

方法

方法（S为字符串）	描述
S.isdigit()	判断字符串中是否全是数字
S.isalpha()	判断字符串是否全为英文字母
S.islower()	判断字符串是否全为小写英文
S.isupper()	判断字符串是否全为大写英文
S.isspace()	判断字符串是否全为空白字符串
S.center(width [,fill])	将原字符串居中，左右默认填充空格
S.count(sub [,start [,end]])	获取一个字符串中字串的个数
S.find(sub [,start [,end]])	获取字符串中子串sub的索引，失败返回-1
S.strip()	返回去掉左右空白字符的字符串
S.lstrip()	返回去掉左侧空白字符的字符串
S.rstrip()	返回去掉右侧空白字符的字符串
S.lower()	将生成的英文转换为小写字符串
s.upper()	将生成为英文转换为大写字符串
S.repace(old, new [,count])	将原字符串的old用new代替，生成一个新的字符串
S.startswith(prefix [,start [,end]])	返回S 是否以pewfix开头
S.endswith(suffix [,start [,end]])	返回S是否是以suffix结尾

字符串的格式化表达式
- 作用：生成一定格式的字符串
- 语法：
  - 格式字符串 % 参数值
  - 格式字符串 % (参数值1, 参数值2, ...)
- 说明：
  - 格式化字符串中以%开头的为占位符，占位符的位置将用参数值替换
- 示例
```
    fmt = "name:%s, age: %d"
    name = "pengyuan"
    age = 25
    s = fmt % (name, age) # "name:pengyuan, age: 25"
```
格式化字符串中的占位符和类型码
- %s 字符串，使用str(obj)转为字符串
- %r 字符串，使用repr(obj)转为字符串
- %c 整数转为字符串，使用chr(i) 函数
- %d 十进制函数
- %o 八进制函数
- %x 十六进制整数（字符a-f小写）
- %X 十六进制整数（字符A-F大写）
- %e 指数型浮点数（e小写）如 2.9e+10
- %E 指数型浮点数（E大写）如 2.9E+10
- %f，%F 浮点十进制形式
- %g，%G 进制进形式浮点或指点浮点自动转换
- %% 等同于一个%字符

占位符和类型码之间的格式语法

% [- + 0 宽度.精度] 类型码
'-' 左对齐(默认是右对齐)
'+' 显示正好
'0' 左侧空白位置补零
宽度：整个数据输出的宽度
精度：保留小数点后多少位，默认6位

示例：

- "%10d" % 123          # '       123'
- '%+10d' % 123         # '      +123'
- '%-10d' % 123         # '123       '
- '%10sd' % ABC         # '       ABC'  
- '%05d' % 123          # '00123'
- '%f' % 3.141456454654 # '3.141593'
- '%7.2f' % 3.141456454654 '   3.14'

2.9 循环语句

while 语句
- 作用: 根据一定条件，重复的执行一条语句或多条语句
- 语法
```
    while 真值表达式:
        语句块1
    else:
        语句块2
```
- 说明
  1. 先执行真值表达式，则是布尔值是都为True或False
  2. 如果真值表达式测试值为True,则执行语句块1，然后返回再重复执行
  3. 如果真值表达式测试值为False,则执行else子句中的语句块2，然后结束此while语句
  4. 注： else子句部分可省略
- while 语句的注意事项
  - 要控制循环真值表达式的值来防止'死循环'
  - 通常用真值表达式内的循环变量来控制循环条件
  - 通常在循环语句块内改变循环变量来控制循环次数和变量走向
- while 语句嵌套
```
    while 真值表达式：
        ···
        while 真值表达式2：
            ···
        else:
            ···
    else:
        ···
```
break 语句：
- 作用：用于循环语句（while, for）中，用来终止当前循环语句的执行
- 说明：
  1. 当break 语句执行后, 此循环语句break之后的语句将不再执行
  2. break通常 if 语句组合使用
  3. break 语句终止循环时，循环语句else子句的语句将不会执行
  4. break 语句只能终止当前循环语句的执行，如国有循环嵌套时不会跳出嵌套的外层循环
  5. break 语句只能在循环语句（while 或 for 语句）内部使用
死循环
- 死循环是循环条件一直成立的循环
- 死循环的else 永不会执行
for 语句
- 作用：用来遍历可迭代对象的数据元素
- 可迭代对像是指能依次获取数据元素的对象
- 可迭代的对象包括：
  - 字符串 str
  - 列表 list
  - 元祖 tuple
  - 字典 dict ...
- 语法：
```
    for 变量列表 in 可迭代对象：
        语句块1
    else:
        语句块2
```
- 说明：
  - 当循环内部使用break语句终止循环时，else子句部分的语句不会执行
range() 函数：
- 格式： rang(stop)
  - 从零开始，每次生成一个整数后加1操作，直到stop为止（不包含stop)
  - range(start, stop[, step])
  - 从start开始，每次生成一个整数后移动step,直到stop为止，不包含stop，且step可以是负数
- 详见： >>> help(range)
- 作用：
  - 用来创建一个生成一系列整数的可迭代对象（也叫整数序列生成器）
- 说明：
  - range 函数调用返回的对象可用于for语句来进行一次迭代取出其中的整数
- 示例：
```
    range(4) # 0,1,2,3
    range(3, 6) # 3,4,5
    range(5, 0, -2) # 5,3,1
    range(4, 0) # 空
```
continue 语句：
- 作用：
  - 用于循环语句中，不再执行本次循环内continue之后的语句，重新开始一次新的循环
- 说明：
  - 在while语句中执行continue语句，将会直接跳转到while语句的真实表达式出重新判断循环条件
  - 在for语句中，执行continue语句，将会从可迭代对象中取一下元素绑定变量后再一次进行循环

3. 列表list

列表的定义：
1. 列表是一种容器（通常用看存储计算机的数据对象）
2. 列表是可以被改变的序列
3. 列表是由一系列特定元素组成的，元素与对象之间可能没有任何的关联关系，但是他们之间有先后顺序
创建空列表的字面值方式
- L = [] # L 绑定空列表

创建非空列表的字面值方式

    L = [1, 2, 3, 4] 
    L = ['许昌', '驻马店', '南京', '深圳', '东莞']
    L = ['鹏远', 25, 3.1415926]
    L = [1, 2, 'one', ['A', 'B', 3, 3.14]]

列表的构造函数list

list() 生成一个空的列表，等同于[]
list(iterable) 可用迭代对象创建一个列表

示例：

    L = list() # L = []
    L = list('hello') # L = ['h', 'e', 'l', 'l', 'o']
    L = list(range(5, 10, 2) # L = [5, 7, 9]

列表的运算

运算符 + += * *=

'+' 用于拼接列表

    x = [1, 2, 3]
    y = [4, 5, 6]
    z = x + y # [1, 2, 3, 4, 5, 6]

'+=' 用于将右侧的可迭代对象的数据追加到原列表中

    x = [1, 2, 3]
    x += [4, 5, 6]  # [1, 2, 3, 4, 5, 6]
    
    x = [1, 2]
    x += "AB" # x = [1, 2, 'A', 'B']
    
    x = [1, 2]
    x += range(3) # x = [1, 2, 0, 1, 2]

用于生成重复的列表

    x = [1, 2] * 3 # x = [1, 2, 1, 2, 1, 2]
    x = list('AB')
    x *=2 # x = ['A', 'B', 'A', 'B']

列表的比较运算

运算符： < <= > >= == !=

比较规则：

同字符串的比较规则完全相同

 [1, 2, 3] < [1, 3, 2] # True
 [1, 2, 3] != [3, 2, 1] # True
 [1, 'Two'] > ['Two', 1] # type Error 出错

列表是可迭代对象
列表的切片
- 列表[:]
- 列表[::]
- 列表的切片取值返回一个列表，规则等同于字符串的切片规则
- 例如：
```
    L  = [0, 1, 2, 3, 4, 5, 6, 7, 8]
    L2 = L[1::2] # L2 = [1,3,5,7]
```

列表切片的赋值

作用:
- 可以改变原列表的排序，可以插入和修改数据
- 可以用切片改变列表对应的元素的值

语法：

    列表[切片slice] = 可迭代对象

说明：
- 赋值运算符的右侧必须是一个可迭代对象

示例

    L = [2, 3, 4]
    L[0:1] = [1.1, 2.2] # L = [1.1, 2.2, 3, 4]
    L[2:] = [3.3, 4.4, 5.5] # L =[1.1, 2.2, 3.3, 4.4, 5.5]
    L[1:2] = [] # L = [1.1, 3.3, 4.4, 5.5]
    
    L = [1, 2, 3, 4, 5, 6]
    L[::-2] = "DEF" # [1, 'F', 3, 'E', 5, 'D']

切片赋值主注意事项：
- 对于步长不等于1的切片赋值，赋值运算符的右侧的可迭代
- 对象提供的数据元素的个数一定要等于切片切出的片数
- 如：
```
    L = [1, 2, 3, 4, 5, 6]
    L[::2] = 'ABC' # 正确
    L[::2] = 'ABCDE' # 错误
```

del语句

用于删除列表的元素

语法：

    del 列表[索引]
    del 列表[切片]

示例：

    L = [0, 1, 2, 3, 4, 5, 6]
    del L[0] # L = [1, 2, 3, 4, 5, 6]
    
    L = [0, 1, 2, 3, 4, 5, 6]
    del L[::2] # L = [1, 3, 5]

列表常用方法

  方法(L 为列表) | 描述
  ---|---
  L.index(v [,begin [,end]]) | 返回对应元素的索引下标，begin未开始索引，end为结束索引，当value不存在时触发VulueError错误
  L.insert(index, obj) | 将某个元素插放到列表中的指定位置
  L.count(x) | 返回列表中元素的个数
  L.remove() | 从列表中删除第一次处出现在列表中的值
  L.copy | 复制此列表（只复制一层,不会复制深层对象）
  L.append(x) | 向列表追加单个元素
  L.extend(x) | 向列表追加另一个列表
  L.clear() | 清空列表，等同等同于L[:] = []
  L.sort(reverse=False) | 将列表中的元素进行排序，默认顺序按值的小到大的顺序排列
  L.reverse() | 将列表的反转，用来改变原列表的先后顺序
  L.pop([index]) | 删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回删除元素的引用关系

字符串的文本解析方法 split 和 join
S 代表字符串
- S.split(sep=None)
  - 将字符串使用sep 作为分隔字符分隔S字符串，返回分隔后的的字符列表，当不给定参数时，用空白字符作为分隔符分隔
- S.join(iterable)
  - 用可迭代对像中的字符串，返回一个中间用S进行分隔的字符串
- 示例：
```
    s = 'Beijing is capital'
    L = s.split(' ') # ["Beijing", "is", "capital"]
    
    L = ["Beijing", "is", "capital"]
    S = ' '.join(L) # 'Beijing is capital'
    
```

浅拷贝深拷贝

浅拷贝 shallow copy

浅拷贝是指在复制过程中只复制一层，不复制深层变量绑定的对象的复制过程

    L = [3.1, 3.2]
    L1 = [1, 2, L]
    L2 = L1.copy()
    L2[2][0] = 3.14
    print(L1) # [1, 2, [3.14, 3.2]]
    print(L2) # [1, 2, [3.14, 3.2]]

浅拷贝等同于 L3 = L1[:]

深拷贝 deep copy

深拷贝通常只对可变对象进行复制，不可变对象通常不会复制

    import copy # 导入copy模块
    L = [3.1, 3.2]
    L1 = [1, 2, L]
    L2 = copy.deepcopy(L1) # 深拷贝
    L2[2][0] = 3.14
    print(L1) # [1, 2, [3.1, 3.2]]   #<<< --- 此处不变
    print(L2) # [1 ,2, [3.14, 3.2]]

列表推导式 list comprehension

列表推到式是用可迭代对象生成列表的表达式
作用：用简易方法生成列表

语法：

[表达式 for 变量 in 可迭代对象]
或
[表达式 for 变量 in 可迭代对象 if 真值表达式]

说明:
- for in 表达式的if 子句可以省略，省略后将对所有生成的对象进行求值处理

示例

    # 生成一个数值为1~9的平方列表
    L = [X ** 2 for x in range(1, 10)]
    
    # 生成1~100 奇数列表(方法1)
    L = [x for x in range(1, 100, 2)]
    # 生成1~100 奇数列表(方法2)
    L = [x for x in range(1, 100) if x % 2 == 1]

列表推导式语法嵌套

语法：

    [表达式 
        for 变量1 in 可迭代对象1 if 真值表达式1
            for 变量2 in 可迭代对象2 if 真值表达式2]

示例：

    L = [x + y for x in "ABC" for y in "123"]

元组 tuple

定义
- 元组是不可变的序列，同list一样，元组可以存放任意类型数据的容器
元组的表示方法
- 用小括号() 括起来，单个元素括起来后加逗号(,) 区分单个对象是对象还是元组
创建空元组的字面值
```
    t = () # 空元组
```

创建非空元祖的字面值表示

    t = 200,
    t = (20,)
    t = (1, 2, 3)
    t = 100, 200, 300

函数type(x) 用来返回x对应的类型

元组的错误示例：

    t = (20) # t 绑定20 这个对象，不是元组
    x, y, z = 100, 200, 300 # 序列赋值
    x, y, z = (100, 200, 300) # 序列赋值
    x, y, z = [100, 200, 300] # 序列赋值
    x, y, z = 'ABC' # 序列赋值

元组的构造(创建)函数 tuple

tuple() # 生成一个空元组，等同于()
tuple(iterable) # 用可迭代对象生成一个元组
示例

    t = tuple() # 等同于 t = ()
    t = tuple(range(1,20,3)) # t = (1, 4, 7)
    t = tuple("ABC") # t = ('A', 'B', 'C')
    t = tuple([1, 2, 3]) # t = (1, 2, 3)

元组的运算
```
    + += * *=
    < <= > >= == !==
    in , not in
    索引[], 切片[:] / [::]
```
- + 加号用于拼接元组
- * 用生成的重复的元组
- 元组的比较运算：
  - 规则与列表的比较规则完全相同
- in / not in 运算符
  - 规则与列表的规则完全相同
- 索引和切片
  - 索引取值和切片取值的规则与列表完全相同
  - 元组不支持索引赋值和切片赋值(因为元组不可被改变)

元组的方法

    T.index(v[, begin[, end]]) # 返回对应元素的索引下标
    T.count(x) # 返回元组中对应的元素个数
    # 详见： >>> help(tuple)
    
    # 序列相关的函数
    len(x), max(x), min(x), sum(x), any(x), all(x)

构造函数：
- str(x) # 创建字符串
- list(iterable) # 创建列表
- tuple(iterable) # 创建元组
序列相关函数
- reversed(可迭代对象) # 返回反向顺序的可迭代对象
- sorted(iterable, key=None, reverse=False) # 返回已排序的列表
容器小结
- 字符串 str # 不可变序列，只能存字符串
- 列表 list # 可变的序列，可以存任意数据
- 元组 tuple # 不了变序列，可以存任意数据

字典 dict

什么是字典
1. 字典是一种可变的容器，可以储存任意类型的数据
2. 字典中的每个数据都是用'键'(key)进行索引，而不像序列可以用整数下标来索引
3. 字典中的数据没有先后关系，字典的存储是无序的
4. 字典中的数据以键(key)-值(value) 对形式进行映射存储
5. 字典的键不能重复，据只能用不可变类型作为字典的键
字典的字面值表示方式
- 字典的表示方式以 {} 括起来，以冒号（：）分割键-值对，各键-值对之间用逗号分隔开
创建空字典的字面值：
```
    d = {} # d 绑定空字典
```

创建非空字典的字面值：

    d = {'name': 'songpengyuan', 'age': 25}
    d = {1: 'one', 2: 'two'}
    d = {'国籍': '中国'}
    d = {1: [1, 2, 3], abc: (11, 22, 3.3)}
    d = {123: list('123')}
    d = {'a': {'b': 200, 'c': [1, 2, 3]}}
    d = {(1970, 1, 1): 'computer year'}

字典的构造函数 dict
- dict() 生成一个字的字典等同于{}
- dict(iterable) 用可迭代对象初始化一个字典
- dict(**kwargs) 用关键字传参形式创建字典
- 示例
```
    d = dict()
    
    # {'name': 'tarena', 'age': '15'}
    d = dict([('name', 'pengyuan'), ['age', '15']])
    
    # {'name': 'pengyuan', 'age': 25}
    d = dict(name = 'pengyuan', age = 25) 
    
    # {'A': 'B', 1: 2}
    d = dict(([1, 2], "AB")) 
```
- 字典的key必须为可变类型
  - bool
  - int
  - float
  - complex
  - str
  - tuple
  - frozenset
  - bytes
- 字典的value 可以是任意类型
- 可变的数据类型有四种
  - list
  - dict
  - set 集合
  - bytrearray 字节数组

字典的基本操作

字典的键索引
- 用[]运算符可以获取字典内"键"对应的值
- 也可以用[]运算符来修改"键"对应的值
- 键索引语法：字典[键]
  - 示例：
```
    d = {}
    d[name] = 'pengyuan' # 创建新的键值
    d['age'] = 15
    d['age'] = 16 # 修改age所对应的值
```

删除字典元素： del 字典[键]

    d = {'name': 'pengyuan', 'age': 15}
    del d['name'] # d = {'age': 15}

字典的成员资格判断 in 运算符
- 可以有in 运算符判断一个键是否存在于字典中，如果存在则返回True,否则返回False
- not in 与 in 相反
```
    d = {'name': 'pengyuan', 'age': 15}
    if 'name' in d:
        print('name 在字典中')
```

字典的迭代访问

字典是可迭代的对象，字典只能对键进行迭代访问

示例：

    d = {'name': 'pengyuan', 'age': 15}
    for x in d:
        print(x)
    ###### 输出 name age

可用于字典的内建函数

len(x) 但会字典的键值对个数
max(x) 返回字典的键的最大值
min(x) 返回字典的键的最小值
sum(x) 返回字典中所有的键的和
any(x) 真值测试，只要有一个键为True，返回True
all(x) 真值测试，当全部键为真值时，返回true

    d = {0: 'zero', 1: 'one', 2: 'two', 3:'three'}
    len(d) # 4
    max(d) # 3
    min(d) # 0
    sum(d) # 6
    any(d) # True
    all(d) # False (因为键 -> 0  是false)

字典的方法

D代表字典对象	描述
D.clear	清空字典
D.pop(key)	移除键，同时返回此键对应的值
D.copy()	返回字典D的副本，只复制一层(浅拷贝)
D.update(D2)	将字典D2合并到D中，如果键相同,则此键的值取D2的值作为新值
D.get(key, default)	返回键key所对应的值，如果没有此键，则返回default
D.keys()	返回可迭代的dict_keys集合对象
D.values()	返回可迭代的dict_values值的对象
D.items()	返回可迭代对象

字典推导式

字典推导式是用可迭代对象创建字典的表达式

语法:

    {键表达式 : 值表达式 for 变量 in 可迭代对象 if 真是表达式}

说明：if 子句部分可省略
示例：
- 生成一个字典，键为数字，值为键的平方
```
    d = {x: x ** 2 for x in range(10}
```

字典 VS 列表

都是可变对象
索引方式不同，列表用整数索引，字典用键索引
字典的插入,删除，修改数据的速度可能会快于列表
列表的存储是有序的，字典的存储是无序的

    c = a + b
    a = b
    b = c 
    # 可改写为
    a, b = b, a + b

集合 set
- 集合是可变的容器
- 集合内的数据对象都是唯一的（不能重复多次的）
- 集合是无序的存储结构，集合中的数据没有先后顺序
- 集合内的元素必须是不可变对象
- 集合是可迭代对象
- 集合是相当于只有键没有值的字典(键则是集合的数据)
创建空集合 s = set()

创建非空集合

    s = {1, 2, 3}
    s = {3.14, True, (1970, 1, 1), 'Hello'}

集合的构造函数

set() 创建一个非空的集合对象（不能使用{}，创建空集合）
set(iterable) 用可迭代对象创建一个新的集合对象

示例：

    s = {1, 3, 5, 7}
    s = set("ABC") # {"A", "B", "c" }
    s = set("ABCC") # {"A", "B", "c" }
    s = set({1: '1', 2: '2'})
    s = set([1, 2, 3.14, "hello"])
    s = set( ('abc', '123', True) ) # {'123', 'abc', True}

集合的运算

交集并集补集子集超集

"&" 生成两个集合的交集

    s1 = {1, 2, 3}
    s2 = {2, 3, 4}
    s3 = s1 & s2 # s3 = {2, 3}

"|" 生成两个集合的并集

    s1 = {1, 2, 3}
    s2 = {2, 3, 4}
    s3 = s1 | s2 # s3 = {1, 2, 3, 4}

"-" 生成两个集合的并集

    s1 = {1, 2, 3}
    s2 = {2, 3, 4}
    # s3 生成属于s1 但不属于 s2 的所有元素的集合
    s3 = s1 | s2 # s3 = {1}

"^" 生成两个集合的对称补集

    s1 = {1, 2, 3}
    s2 = {2, 3, 4}
    # s3 也等于 (s1 - s2) | (s2 - s1)
    s3 = s1 ^ s2 # s3 = {1, 4}

">" 判断一个集合是另一个集合的超集

"<" 判断一个集合是另一个集合的子集

    s1 = {1, 2, 3}
    s2 = {2, 3}
    s1 > s2 # True  s1 为 s2 的超集
    s1 < s2 # Fasle s2 为 是 的子集

"== !=" 集合相同 / 不相同

    s1 = {1, 2, 3}
    s2 = {3, 2, 1}
    s1 == s2 # True 集合没有先后属顺序

"in, not in" 运算符
- 等同于字典中的 in, not in
- 作于集合中，判断某个值是否存在于集合中

集合和字典的优缺点
- in / not in 运算符的判断速度快些

能用于集合的函数（部分）

header 1	header 2
S.add(e)	在集合中添加一个新元素，如果元素已存在则不变
S.remove(e)	从集合中删除一个元素，如元素不存在于集合中，则会产生一个KeyError
S.discard(e)	从集合S中移除一个元素e,在元素e不存在时什么都不做
S.clear()	清空集合内的所有元素
S.copy()	将集合进行一次浅拷贝
S.pop()	从集合中删除一个随机元素，如果此集合为空，则引发KeyError异常
S.update(s2)	用S与s2得到的全集更新变量S
S.difference(s2)	用S - s2 运算，返回存在于S中,但不再S2中的所有元素的集合
S.difference_update(s2)	等同于S = S - S2
S.intersection(s2)	等同于 S & s2
S.intersection_update(s2)	等同于S = S & s2
S.issubset(s2)	如果S 与 s2 交集为空，返回True,非空则为返回False
S.issuperset(...)	如果S为s2的子集返回True,否则返回False
S.symmetric_difference(s2)	返回对称补集，等同于S ^ s2
S.symmetric_difference_update(s2)	用S与s2的对称补集更新S
S.union(s2)	生成S 与 s2 的全集

集合的推导式
- 集合推导式是用可迭代对象生成集合的表达式
- 语法：
  - {表达式 for 变量 in 可迭代对象 [if 真值表达式]}
  - 注：[]括号部分可以省略
- 示例：
```
    L = [1, 3, 4, 7, 3, 4, 4]
    s = {x for x in L} 
```
- 集合推导式可以嵌套，语法同列表推导式一致

固定集合forzenset

固定集合是不可变的，无序的，含有唯一元素的集合
作用
- 固定集合可以作为字典的键，还可以作为集合的值
固定集合的构造函数
- frozenset() 创建一个空的固定集合
- frozenset(iterable) 用可迭代对象创建固定集合

示例：

    f = frozenset() # 空固定集合
    f = frozenset([1, 3, 5, 7]) # f = frozenset({1, 2, 3, 7})

固定集合的运算

    - & 交集
    - | 并集
    - -  补集
    - ^  对称补集
    - <
    - <=
    - >
    - >=
    - ==
    - !=
    - in / not in 
    (以上运算符 和集合set中的用法完全一致)

固定集合的方法
- 相当集合的方法

python 入门之计算机基础、linux命令、数据、运算（万字整理）1