Python学习之基础(1)

本笔记参考《尚硅谷Python零基础入门教程》整理总结，供后续学习查阅

1.介绍

1.1 编程语言

人通过计算机的语言来控制计算机，计算机语言其实和人类的语言没有本质的区别，不同点就是交流的主体不同！

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

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

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

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

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

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

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

1.3 python介绍

Python是解释型语言

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

Life is short you need Python （人生苦短，我用Python）    

Python的用途：
    WEB应用
        Facebook 豆瓣 。。。
    爬虫程序
    科学计算
    自动化运维
    大数据（数据清洗）
    云计算
    桌面软件/游戏
    人工智能
    。。。     

开发环境搭建就是安装Python的解释器
Python的解释器分类：
    CPython（官方）
        用c语言编写的Python解释器
    PyPy
        用Python语言编写的Python解释器
    IronPython
        用.net编写的Python解释器
    Jython
        用Java编写的Python解释器
        
        
一般会将Python代码编写到一个py文件中，然后通过python指令来执行文件中的代码
python3.x和2.x都是两个并行版本，3.x版本并不兼容2.x版本


Python是一门面向对象的编程语言
- 面向对象的编程语言
    - 面向对象的编程语言，关注的是对象，而不关注过程 
    - 对于面向对象的语言来说，一切都是对象       
    - 例子：
        1.孩他妈起床叫孩子上学

    - 面向对象的编程思想，将所有的功能统一保存到对应的对象中
        比如，妈妈功能保存到妈妈的对象中，孩子的功能保存到孩子对象中
        要使用某个功能，直接找到对应的对象即可
    - 这种方式编写的代码，比较容易阅读，并且比较易于维护，容易复用。
    - 但是这种方式编写，不太符合常规的思维，编写起来稍微麻烦一点

2.基础语法

2.1 概念

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

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

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

4.函数（function）
    函数就是一种语句，函数专门用来完成特定的功能
    函数长的形如：xxx()          
    函数的分类：
        内置函数
            - 由Python解释器提供的函数，可以在Python中直接使用
        自定义函数   
            - 由程序员自主的创建的函数
    当我们需要完成某个功能时，就可以去调用内置函数，或者自定义函数 
    函数的两个要素：
        参数
            - ()中的内容就是函数的参数
            - 函数中可以没有参数，也可以有多个参数，多个参数之间使用,隔开
        返回值        
            - 返回值是函数的返回结果，不是所有的函数都有返回值

5.数据类型
数据类型指的就是变量的值得类型，也就是可以为变量赋哪些值 
    数值
        整型
            布尔值
        浮点型
        复数
    字符串
    空值

2.2 基本语法

1.在Python中严格区分大小写
2.Python中的每一行就是一条语句，每条语句以换行结束，不用在后面加分号了
3.Python中每一行语句不要过长（规范中建议每行不要超过80个字符）
4.一条语句可以分多行编写，多行编写时语句后边以\结尾
```
print("我们 一起 学\
      python")
```
5.Python是缩进严格的语言，所以在Python中不要随便写缩进
6.在Python中使用#来表示注释，#后的内容都属于注释，注释的内容将会被解释器所忽略，注释要求简单明了，一般习惯上#后边会跟着一个空格，多行注释可以使用三个单引号或者三个双引号进行注释，引号之间的内容不会被执行。
```
# 这是单行注释
print("我们 一起 学\
      python")

'''
这是多行注释
'''
"""
这是多行注释
"""
```

2.3 字面量和变量

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

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

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

# Python中使用变量，不需要声明，直接为变量赋值即可
a = 10

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

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

2.4 标识符

在Python中所有可以自主命名的内容都属于标识符比如：变量名、函数名、类名标识符必须遵循标识符的规范

1.标识符中可以含有字母、数字、_，但是不能使用数字开头例子：a_1 _a1 1a
_2.标识符不能是Python中的关键字和保留字也不建议使用Python中的函数名作为标识符,因为这样会导致函数被覆盖
_3.命名规范：在Python中注意遵循两种命名规范：下划线命名法所有字母小写，单词之间使用_分割 max_length min_length hello_world xxx_yyy_zzz 帕斯卡命名法（大驼峰命名法）
首字母大写，每个单词开头字母大写，其余字母小写 MaxLength MinLength HelloWorld XxxYyyZzz

如果使用不符合标准的标识符，将会报错 SyntaxError: invalid syntax

2.5 数字

1.在Python数值分成了三种：整数、浮点数（小数）、复数

2.在Python中所有的整数都是int类型，Python中的整数的大小没有限制，可以是一个无限大的整数

a = 10
c = 999999999999999999999999999999999999999999999 ** 100

3.如果数字的长度过大，可以使用下划线作为分隔符

c = 123_456_789

4.进制表示

#10进制的数字不能以0开头
d = 0123
# 二进制 0b开头
c = 0b10
# 八进制 0o开头
c = 0o10
# 十六进制 0x开头
c = 0x10

5.浮点数（小数），在Python中所有的小数都是float类型

c = 1.23
c = 4.56

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

2.6 字符串

1.在Python中字符串需要使用引号引起来

s = 'hello'
# 引号可以是双引号，也可以是单引号，但是注意不要混着用
s = 'hello'
s = "hello" # s = 'hello" 引号不能混合使用

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

2.长字符串，单引号和双引号不能跨行使用

# 若要使用跨行，可以在里面加上`\`即可
s = '锄禾日当午，\
汗滴禾下土，\
谁知盘中餐，\
粒粒皆辛苦'

# 或者使用三重引号来表示一个长字符串 ''' """，三重引号可以换行，并且会保留字符串中的格式
s = '''锄禾日当午，
汗滴禾下土，
谁知盘中餐，
粒粒皆辛苦'''

3.转义字符

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

4.格式化字符串

# 字符串之间也可以进行加法运算
# 如果将两个字符串进行相加，则会自动将两个字符串拼接为一个,但 字符串只能不能和其他的类型进行加法运算
a = 'abc' + 'haha' + '哈哈'

# 在创建字符串时，可以在字符串中指定占位符
# %s 在字符串中表示任意字符
# %f 浮点数占位符
# %d 整数占位符
b = 'Hello %s'%'孙悟空' #占位符后面紧跟%+填充数据
print(b)  #输出结果为：Hello 孙悟空

b = 'hello %s 你好 %s'%('tom','孙悟空') #结果：hello tom 你好 孙悟空
b = 'hello %3.5s'%'abcdefg' # %3.5s字符串的长度限制在3-5之间
b = 'hello %s'%123.456
b = 'hello %.2f'%123.456
b = 'hello %d'%123.95

# 可以通过在字符串前添加一个f来创建一个格式化字符串,前提是变量是有效的，是之前用过的
# 在格式化字符串中可以直接嵌入变量
c = f'hello {a} {b}'  #c结果：hello abchaha哈哈 hello tom 你好 孙悟空
print(f'a = {a}')

# 创建一个变量来保存你的名字
name = '孙悟空'

# 使用四种方式来输出，欢迎 xxx 光临
# 拼串
print('欢迎 '+name+' 光临！')
# 多个参数
print('欢迎',name,'光临！')
# 占位符
print('欢迎 %s 光临！'%name)
# 格式化字符串
print(f'欢迎 {name} 光临！')

5.复制字符串

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

print(a)

2.7 布尔

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

# 布尔值实际上也属于整型，True就相当于1，False就相当于0
# print(1 + True) # 结果为2

2.8 空值

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

2.9 类型检查与类型转换

检查

# 通过类型检查，可以检查只能值（变量）的类型

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

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

# type()用来检查值的类型
# 该函数会将检查的结果作为返回值返回，可以通过变量来接收函数的返回值
c = type('123')
c = type(a)
# 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'>

转换

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

# 类型转换四个函数 int() float() str() bool()
# int() 可以用来将其他的对象转换为整型
# 规则：
#   布尔值：True -> 1   False -> 0
#   浮点数：直接取整，省略小数点后的内容
#   字符串：合法的整数字符串，直接转换为对应的数字
#           如果不是一个合法的整数字符串，则报错 ValueError: invalid literal for int() with base 10: '11.5'
#   对于其他不可转换为整型的对象，直接抛出异常 ValueError
# int()函数不会对原来的变量产生影响，他是对象转换为指定的类型并将其作为返回值返回,如果希望修改原来的变量，则需要对变量进行重新赋值
a = True
a = int(a)
print('a =',a)
# float() 和 int()基本一致，不同的是它会将对象转换为浮点数
# str() 可以将对象转换为字符串
#  True -> 'True'
#  False -> 'False'
#  123 -> '123' 
#  。。。
#  bool() 可以将对象转换为布尔值，任何对象都可以转换为布尔值
#   规则：对于所有表示空性的对象都会转换为False，其余的转换为True
#       哪些表示的空性：0 、 None 、 '' ...
a = None
a = bool(a)
print('a =',a)

2.10 对象

2.10.1 对象结构

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

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


    - value（值）
        > 值就是对象中存储的具体的数据
        > 对于有些对象值是可以改变的
        > 对象分成两大类，可变对象 不可变对象
            可变对象的值可以改变
            不可变对象的值不能改变，之前学习的对象都是不可变对象
            
print(id(22))   #结果：1345907536

2.10.2 变量和对象

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

2.11 运算符

运算符的优先级

# 和数学中一样，在Python运算也有优先级，比如先乘除 后加减
# 运算符的优先级可以根据优先级的表格来查询，
#   在表格中位置越靠下的运算符优先级越高，优先级越高的越优先计算
#   如果优先级一样则自左向右计算
#  关于优先级的表格，你知道有这么一个东西就够了，千万不要去记
#  在开发中如果遇到优先级不清楚的,则可以通过小括号来改变运算顺序
a = 1 + 2 * 3

# 一样 and高 or高
# 如果or的优先级高，或者两个运算符的优先级一样高
#   则需要先进行或运算，则运算结果是3
# 如果and的优先级高，则应该先计算与运算
#   则运算结果是1
a = 1 or 2 and 3

# print(a)

# 逻辑运算符（补充）
# 逻辑运算符可以连着使用
result = 1 < 2 < 3 # 相当于 1 < 2 and 2 < 3
result = 10 < 20 > 15

print(result)

2.11.1 算术运算符

+ 加法运算符（如果是两个字符串之间进行加法运算，则会进行拼串操作）

- 减法运算符

*乘法运算符（如果将字符串和数字相乘，则会对字符串进行复制操作，将字符串重复指定次数） / 除法运算符，运算时结果总会返回一个浮点类型 // 整除，只会保留计算后的整数位，总会返回一个整型 ** 幂运算，求一个值的几次幂 % 取模，求两个数相除的余数

a = a - 2 # 用变量a的值减去2，然后再赋值给a

a = 5 * 5
a = 10 / 5
a = 5 // 2 

a = 2 ** 2
a = 16 ** 0.5 # 求16的平方根

a = 10 % 5 # 0
a = 10 % 4 # 2
print("a =",a)

2.11.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 = 10
# a = a + 5
# a += 5
a -= 5
a *= 5
a **= 2
a /= 25
a = 25.0 # 在对浮点数做算术运算时，结果也会返回一个浮点数

2.11.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 = 1 == True # True
result = 1 is True # False
result = 1 is not True # True

# 在Python中可以对两个字符串进行大于（等于）或小于（等于）的运算，
#   当对字符串进行比较时，实际上比较的是字符串的Unicode编码
#   比较两个字符串的Unicode编码时，是逐位比较的
#   利用该特性可以对字符串按照字母顺序进行排序，但是对于中文来说意义不是特别大
#   注意：如果不希望比较两个字符串的Unicode编码，则需要将其转换为数字然后再比较
#   0061 > 0062
result = 'a' > 'b' # False
result = 'c' < 'd' # True
result = 'ab' > 'b' # False

2.11.4 逻辑运算符

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

not 逻辑非 not可以对符号右侧的值进行非运算对于布尔值，非运算会对其进行取反操作，True变False，False变True 对于非布尔值，非运算会先将其转换为布尔值，然后再取反
and 逻辑与 and可以对符号两侧的值进行与运算只有在符号两侧的值都为True时，才会返回True，只要有一个False就返回False 与运算是找False的 Python中的与运算是短路的与，如果第一个值为False，则不再看第二个值
or 逻辑或 or 可以对符号两侧的值进行或运算或运算两个值中只要有一个True，就会返回True 或运算是找True的 Python中的或运算是短路的或，如果第一个值为True，则不再看第二个值

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

result = True and True # True

非布尔值的与或运算

# 非布尔值的与或运算
#   当我们对非布尔值进行与或运算时，Python会将其当做布尔值运算，最终会返回原值
#   与运算的规则
#       与运算是找False的，如果第一个值是False，则不看第二个值
#       如果第一个值是False，则直接返回第一个值，否则返回第二个值
#   或运算的规则
#       或运算是找True的，如果第一个值是True，则不看第二个值
#       如果第一个值是True，则直接返回第一个值，否则返回第二个值  
True and print('你猜我出来吗？') 第一个值是True，会看第二个值，所以print()会执行
False and print('你猜我出来吗？')第一个值是False，不会看第二个值，所以print()不会执行
result = 1 and 2 # 2
result = 1 and 0 # 0

2.11.5 条件运算符

语法：语句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)

2.12 流程控制语句

Python代码在执行时是按照自上向下顺序执行的。通过流程控制语句，可以改变程序的执行顺序，也可以让指定的程序反复执行多次流程控制语句分成两大类：条件判断语句，循环语句

2.12.1 if

语法：if 条件表达式 : 
          代码块
执行的流程：if语句在执行时，会先对条件表达式进行求值判断，
  如果为True，则执行if后的语句
  如果为False，则不执行
默认情况下，if语句只会控制紧随其后的那条语句，如果希望if可以控制多条语句，
  则可以在if后跟着一个代码块
if False :
    print(123)

缩进有两种方式，一种是使用tab键，一种是使用空格（四个）
#   Python的官方文档中推荐我们使用空格来缩进
#   Python代码中使用的缩进方式必须统一

可以使用逻辑运算符来连接多个条件，如果希望所有条件同时满足，则需要使用and,如果希望只要有一个条件满足即可，则需要使用or
num = 28
if num > 10 and num < 20 :
    print('num比10大,num比20小！')

代码块
  代码块中保存着一组代码，同一个代码块中的代码，要么都执行要么都不执行
  代码块就是一种为代码分组的机制
  如果要编写代码块，语句就不能紧随在:后边，而是要写在下一行
  代码块以缩进开始，直到代码恢复到之前的缩进级别时结束

# 检查用户的输入是否合法
if dog_age > 0 :
    # 如果狗的年龄在两岁以下（包含两岁）
    if dog_age <= 2 :
        # 直接将当前的年龄乘以10.5
        like_person_age = dog_age * 10.5
    # 如果狗的年龄在两岁以上
    else :
        # 计算前两岁相当于人类的年纪
        like_person_age = 2 * 10.5
        # 计算超过两岁的部分相对于人类的年纪，并进行相加
        like_person_age += ( dog_age - 2 ) * 4

    print(dog_age,'岁的狗，年纪相当于',like_person_age,'岁的人')
else :
    print('请输入一个合法的年龄！')

# input()函数:
# 该函数用来获取用户的输入,input()调用后，程序会立即暂停，等待用户输入
# 获取用户输入的用户名
username = input('请输入你的用户名:')
# 判断用户名是否是admin
if username == 'admin' :
    print('欢迎管理员光临！')

if-else

if-else语句
语法： 
  if 条件表达式 :
      代码块
  else :
      代码块
执行流程：
  if-else语句在执行时，先对if后的条件表达式进行求值判断
      如果为True，则执行if后的代码块
      如果为False，则执行else后的代码块

age = 7
if age > 17 :
    print('你已经成年了~~')
else :
    print('你还未成年~~')

if-else-else

if-elif-else语句
语法：
  if 条件表达式 :
      代码块
  elif 条件表达式 :
      代码块
  elif 条件表达式 :
      代码块
  elif 条件表达式 :
      代码块
  else :
      代码块

执行流程：
  if-elif-else语句在执行时，会自上向下依次对条件表达式进行求值判断，
      如果表达式的结果为True，则执行当前代码块，然后语句结束
      如果表达式的结果为False，则继续向下判断，直到找到True为止
      如果所有的表达式都是False，则执行else后的代码块
  if-elif-else中只会有一个代码块会执行

age = 68

if age >= 18 and age < 30 :
    print('你已经成年了！')
elif age >= 30 and age < 60 :
    print('你已经中年了！')
elif age >= 60 :
    print('你已经退休了！')

2.12.2 while

循环语句可以使指定的代码块重复指定的次数

循环语句分成两种，while循环和 for循环

语法：
  while 条件表达式 :
      代码块
  else :
      代码块
执行流程：
  while语句在执行时，会先对while后的条件表达式进行求值判断，
      如果判断结果为True，则执行循环体（代码块），
      循环体执行完毕，继续对条件表达式进行求值判断，以此类推，
      直到判断结果为False，则循环终止，如果循环有对应的else，则执行else后的代码块
        
i = 0
while i < 10 :
    i += 1
    print(i,'hello')
else :
    print('else中的代码块')

2.12.3 for

for 循环用于迭代序列（即列表，元组，字典，集合或字符串）。

这与其他编程语言中的 for 关键字不太相似，而是更像其他面向对象编程语言中的迭代器方法。

通过使用 for 循环，我们可以为列表、元组、集合中的每个项目等执行一组语句。

for 循环不需要预先设置索引变量。

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x)

2.12.4 break continue pass

break:可以用来立即退出循环语句（包括else）

continue:可以用来跳过当次循环

pass:是用来在判断或循环语句中占位的

i = 0
while i < 5:
    if i == 3:
        break
    print(i)
    i += 1
else :
    print('循环结束')

2.13 序列

序列是Python中最基本的一种数据结构
数据结构指计算机中数据存储的方式
序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引）并且序列中的数据会按照添加的顺序来分配索引
序列的分类：可变序列（序列中的元素可以改变）： > 列表（list）不可变序列（序列中的元素不能改变）： > 字符串（str）
> 元组（tuple）

2.13.1 列表（list）

就像java里的array数组一样

列表是Python中的一个对象
对象（object）就是内存中专门用来存储数据的一块区域
之前我们学习的对象，像数值，它只能保存一个单一的数据
列表中可以保存多个有序的数据
列表是用来存储对象的对象
列表的使用： 1.列表的创建 2.操作列表中的数据

# 创建列表，通过[]来创建列表
my_list = [] # 创建了一个空列表
# print(my_list , type(my_list))

# 列表存储的数据，我们称为元素
# 一个列表中可以存储多个元素，也可以在创建列表时，来指定列表中的元素
# 当向列表中添加多个元素时，多个元素之间使用,隔开
my_list = [10,20,30,40,50] # 创建了一个保护有5个元素的列表
# 列表中可以保存任意的对象
my_list = [10,'hello',True,None,[1,2,3],print]

# 列表中的对象都会按照插入的顺序存储到列表中，
#   第一个插入的对象保存到第一个位置，第二个保存到第二个位置
# 我们可以通过索引（index）来获取列表中的元素
#   索引是元素在列表中的位置，列表中的每一个元素都有一个索引
#   索引是从0开始的整数，列表第一个位置索引为0，第二个位置索引为1，第三个位置索引为2，以此类推
my_list = [10,20,30,40,50]

# 通过索引获取列表中的元素
# 语法：my_list[索引] my_list[0]
# print(my_list[4])
# 如果使用的索引超过了最大的范围，会抛出异常
# print(my_list[5]) IndexError: list index out of range

# 获取列表的长度，列表中元素的个数
# len()函数，通过该函数可以获取列表的长度
# 获取到的长度的值，是列表的最大索引 + 1
print(len(my_list)) # 5

切片

# 切片指从现有列表中，获取一个子列表
# 创建一个列表，一般创建列表时，变量的名字会使用复数
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']

# 通过切片来获取指定的元素
# 语法：列表[起始:结束] 
#   通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素
#   做切片操作时，总会返回一个新的列表，不会影响原来的列表
#   起始和结束位置的索引都可以省略不写
#   如果省略结束位置，则会一直截取到最后
#   如果省略起始位置，则会从第一个元素开始截取
#   如果起始位置和结束位置全部省略，则相当于创建了一个列表的副本
print(stus[1:])
print(stus[:3])
print(stus[:])
print(stus)

#可以在上面增加步长来选择：
# 语法：列表[起始:结束:步长] 
# 步长表示，每次获取元素的间隔，默认值是1
# print(stus[0:5:3])
# 步长不能是0，但是可以是负数
# print(stus[::0]) ValueError: slice step cannot be zero
# 如果是负数，则会从列表的后部向前边取元素
print(stus[::-1])


# 列表的索引可以是负数
# 如果索引是负数，则从后向前获取元素，-1表示倒数第一个，-2表示倒数第二个 以此类推
print(stus[-2])

通用操作

# +可以将两个列表拼接为一个列表
my_list = [1,2,3] + [4,5,6]

# * 可以将列表重复指定的次数
my_list = [1,2,3] * 5

# in 和 not in
# in用来检查指定元素是否存在于列表中
#   如果存在，返回True，否则返回False
# not in用来检查指定元素是否不在列表中
#   如果不在，返回True，否则返回False
# 创建一个列表
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精','沙和尚','沙和尚']
print('牛魔王' not in stus)
print('牛魔王' in stus)
# len()获取列表中的元素的个数
# min() 获取列表中的最小值
# max() 获取列表中的最大值
arr = [10,1,2,5,100,77]
# print(min(arr) , max(arr))


# 通过 对象.方法() 的形式调用
# s.index() 获取指定元素在列表中的第一次出现时索引
print(stus.index('沙和尚'))
# index()的第二个参数，表示查找的起始位置 ， 第三个参数，表示查找的结束位置
print(stus.index('沙和尚',3,7))
# 如果要获取列表中没有的元素，会抛出异常
print(stus.index('牛魔王')) ValueError: '牛魔王' is not in list
# s.count() 统计指定元素在列表中出现的次数
print(stus.count('牛魔王'))

列表修改

# 创建一个列表
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']
# 修改列表中的元素
# 直接通过索引来修改元素
stus[0] = 'sunwukong'
stus[2] = '哈哈'

# 通过del来删除元素
del stus[2] # 删除索引为2的元素

# 通过切片来修改列表
# 在给切片进行赋值时，只能使用序列
# stus[0:2] = ['牛魔王','红孩儿'] 使用新的元素替换旧元素
# stus[0:2] = ['牛魔王','红孩儿','二郎神']
# stus[0:0] = ['牛魔王'] # 向索引为0的位置插入元素
# 当设置了步长时，序列中元素的个数必须和切片中元素的个数一致
# stus[::2] = ['牛魔王','红孩儿','二郎神']

# 通过切片来删除元素
# del stus[0:2]
# del stus[::2]
# stus[1:3] = []
# 以上操作，只适用于可变序列
s = 'hello'
# s[1] = 'a' 不可变序列，无法通过索引来修改
# 可以通过 list() 函数将其他的序列转换为list,然后再根据list方式进行操作

列表方法

# 列表的方法
stus = ['孙悟空','猪八戒','沙和尚','唐僧']
print('原列表：',stus)

# append() 
# 向列表的最后添加一个元素
stus.append('唐僧')

# insert()
# 向列表的指定位置插入一个元素
# 参数：
#   1.要插入的位置
#   2.要插入的元素
stus.insert(2,'唐僧')

# extend()
# 使用新的序列来扩展当前序列
# 需要一个序列作为参数，它会将该序列中的元素添加到当前列表中
stus.extend(['唐僧','白骨精'])
stus += ['唐僧','白骨精']

# clear()
# 清空序列
stus.clear()

# pop()
# 根据索引删除并返回被删除的元素

result = stus.pop(2) # 删除索引为2的元素
result = stus.pop() # 删除最后一个
print('result =',result)

# remove()
# 删除指定值得元素，如果相同值得元素有多个，只会删除第一个
stus.remove('猪八戒')

# reverse()
# 用来反转列表
stus.reverse()

# sort()
# 用来对列表中的元素进行排序，默认是升序排列
# 如果需要降序排列，则需要传递一个reverse=True作为参数
my_list = list('asnbdnbasdabd')
my_list = [10,1,20,3,4,5,0,-2]

print('修改前',my_list)

my_list.sort(reverse=True)
print('修改后',my_list)
# print('修改后：',stus)

遍历列表

# 遍历列表，指的就是将列表中的所有元素取出来
# 创建列表
stus = ['孙悟空','猪八戒','沙和尚','唐僧','白骨精','蜘蛛精']

# 遍历列表
print(stus[0])
print(stus[1])
print(stus[2])
print(stus[3])

# 通过while循环来遍历列表
 i = 0
 while i < len(stus):
     print(stus[i])
     i += 1

# 通过for循环来遍历列表
# 语法：
#   for 变量 in 序列 :
#       代码块
# for循环的代码块会执行多次，序列中有几个元素就会执行几次
#   没执行一次就会将序列中的一个元素赋值给变量，
#   所以我们可以通过变量，来获取列表中的元素
for s in stus :
    print(s)

range()

# range()是一个函数，可以用来生成一个自然数的序列
r = range(5) # 生成一个这样的序列[0,1,2,3,4]
r = range(0,10,2)
r = range(10,0,-1)
# 该函数需要三个参数
#   1.起始位置（可以省略，默认是0）
#   2.结束位置
#   3.步长（可以省略，默认是1）

# print(list(r))

# 通过range()可以创建一个执行指定次数的for循环
# for()循环除了创建方式以外，其余的都和while一样，
#   包括else、包括break continue都可以在for循环中使用
#   并且for循环使用也更加简单
# 将之前使用while循环做的练习，再使用for循环完成一次！
for i in range(30):
    print(i)

# for s in 'hello':
#     print(s)

2.13.2 元组（tuple）

元组是一个不可变的序列
它的操作的方式基本上和列表是一致的
所以你在操作元组时，就把元组当成是一个不可变的列表就ok了
一般当我们希望数据不改变时，就使用元组，其余情况都使用列表

# 创建元组
# 使用()来创建元组
my_tuple = () # 创建了一个空元组
print(my_tuple,type(my_tuple)) # <class 'tuple'>

my_tuple = (1,2,3,4,5) # 创建了一个5个元素的元组
# 元组是不可变对象，不能尝试为元组中的元素重新赋值
my_tuple[3] = 10 TypeError: 'tuple' object does not support item assignment
print(my_tuple[3])

# 当元组不是空元组时，括号可以省略
# 如果元组不是空元组，它里边至少要有一个,
my_tuple = 10,20,30,40
my_tuple = 40,
print(my_tuple , type(my_tuple))

# 元组的解包（解构）
# 解包指就是将元组当中每一个元素都分别赋值给一个变量
a,b,c,d = my_tuple  #相当于把my_tuple每一个元素分别赋值给a,b,c,d

print("a =",a)
print("b =",b)
print("c =",c)
print("d =",d)

a = 100
b = 300
# 交互a 和 b的值，这时我们就可以利用元组的解包
a , b = b , a

# 在对一个元组进行解包时，变量的数量必须和元组中的元素的数量一致
# 也可以在变量前边添加一个*，这样变量将会获取元组中所有剩余的元素
a , b , *c = my_tuple
a , *b , c = my_tuple
*a , b , c = my_tuple
a , b , *c = [1,2,3,4,5,6,7]
a , b , *c = 'hello world'
# 不能同时出现两个或以上的*变量
# *a , *b , c = my_tuple SyntaxError: two starred expressions in assignment
print('a =',a)
print('b =',b)
print('c =',c)

2.13.3 字典（dict）

字典属于一种新的数据结构，称为映射（mapping）
字典的作用和列表类似，都是用来存储对象的容器
列表存储数据的性能很好，但是查询数据的性能的很差
在字典中每一个元素都有一个唯一的名字，通过这个唯一的名字可以快速的查找到指定的元素
在查询元素时，字典的效率是非常快的
在字典中可以保存多个对象，每个对象都会有一个唯一的名字这个唯一的名字，我们称其为键（key），通过key可以快速的查询value 这个对象，我们称其为值（value）所以字典，我们也称为叫做键值对（key-value）结构每个字典中都可以有多个键值对，而每一个键值对我们称其为一项（item）

字典创建

# 使用 {} 来创建字典
# 语法：{k1:v1,k2:v2,k3:v3}
d = {} # 创建了一个空字典

# 使用 dict()函数来创建字典
# 每一个参数都是一个键值对，参数名就是键，参数名就是值（这种方式创建的字典，key都是字符串）
d = dict(name='孙悟空',age=18,gender='男') 

# 创建一个有数据的字典
# 语法：
#   {key:value,key:value,key:value}
#   字典的值可以是任意对象
#   字典的键可以是任意的不可变对象（int、str、bool、tuple ...），但是一般我们都会使用str
#       字典的键是不能重复的，如果出现重复的后边的会替换到前边的
# d = {'name':'孙悟空' , 'age':18 , 'gender':'男' , 'name':'sunwukong'}
d = {
'name':'孙悟空' , 
'age':18 , 
'gender':'男' , 
'name':'sunwukong'
}

字典操作

# 需要根据键来获取值
print(d['name'],d['age'],d['gender'])

# 如果使用了字典中不存在的键，会报错
print(d['hello']) KeyError: 'hello'
    
# 也可以将一个包含有双值子序列的序列转换为字典
# 双值序列: 序列中只有两个值，[1,2] ('a',3) 'ab'
# 子序列: 如果序列中的元素也是序列，那么我们就称这个元素为子序列
# 比如[(1,2),(3,5)]，一个序列中包含子序列，每个子序列只有两个元素
d = dict([('name','孙悟饭'),('age',18)])
# print(d , type(d))
d = dict(name='孙悟空',age=18,gender='男') 
    
# len() 获取字典中键值对的个数
print(len(d))    
    
# in 检查字典中是否包含指定的键
# not in 检查字典中是否不包含指定的键
print('hello' in d)   
    
# 获取字典中的值，根据键来获取值
# 语法：d[key]
print(d['age'])    
    
# 通过[]来获取值时，如果键不存在，会抛出异常 KeyError
# get(key[, default]) 该方法用来根据键来获取字典中的值
#   如果获取的键在字典中不存在，会返回None
#   也可以指定一个默认值，来作为第二个参数，这样获取不到值时将会返回默认值
print(d.get('name'))
print(d.get('hello','默认值'))    

# 修改字典
# d[key] = value 如果key存在则覆盖，不存在则添加
d['name'] = 'sunwukong' # 修改字典的key-value
d['address'] = '花果山' # 向字典中添加key-value

# setdefault(key[, default]) 可以用来向字典中添加key-value
#   如果key已经存在于字典中，则返回key的值，不会对字典做任何操作
#   如果key不存在，则向字典中添加这个key，并设置value
result = d.setdefault('name','猪八戒')
result = d.setdefault('hello','猪八戒')

# update([other])
# 将其他的字典中的key-value添加到当前字典中
# 如果有重复的key，则后边的会替换到当前的
d = {'a':1,'b':2,'c':3}
d2 = {'d':4,'e':5,'f':6, 'a':7}
d.update(d2)

# 删除，可以使用 del 来删除字典中的 key-value
del d['a']
del d['b']

# popitem()
# 随机删除字典中的一个键值对，一般都会删除最后一个键值对
#   删除之后，它会将删除的key-value作为返回值返回
#   返回的是一个元组，元组中有两个元素，第一个元素是删除的key，第二个是删除的value
# 当使用popitem()删除一个空字典时，会抛出异常 KeyError: 'popitem(): dictionary is empty'
d.popitem()
result = d.popitem()

# pop(key[, default])
# 根据key删除字典中的key-value
# 会将被删除的value返回！
# 如果删除不存在的key，会抛出异常
#   如果指定了默认值，再删除不存在的key时，不会报错，而是直接返回默认值
result = d.pop('d')
result = d.pop('z','这是默认值')

# clear()用来清空字典
d.clear()

# copy()
# 该方法用于对字典进行浅复制
# 复制以后的对象，和原对象是独立，修改一个不会影响另一个
# 注意，浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制
d = {'a':1,'b':2,'c':3}
d2 = d.copy()

字典遍历

# keys() 该方法会返回字典的所有的key
#   该方法会返回一个序列，序列中保存有字典的所有的键
d = {'name':'孙悟空','age':18,'gender':'男'}

# 通过遍历keys()来获取所有的键
# for k in d.keys() :
#     print(k , d[k])

# values()
# 该方法会返回一个序列，序列中保存有字典的左右的值
# for v in d.values():
#     print(v)

# items()
# 该方法会返回字典中所有的项
# 它会返回一个序列，序列中包含有双值子序列
# 双值分别是，字典中的key和value
# print(d.items())
for k,v in d.items() :
    print(k , '=' , v)

2.13.4 集合（set）

集合和列表非常相似
不同点： 1.集合中只能存储不可变对象 2.集合中存储的对象是无序（不是按照元素的插入顺序保存） 3.集合中不能出现重复的元素

集合

# 集合
# 使用 {} 来创建集合
s = {10,3,5,1,2,1,2,3,1,1,1,1} # <class 'set'>
# s = {[1,2,3],[4,6,7]} TypeError: unhashable type: 'list'
# 使用 set() 函数来创建集合
s = set() # 空集合
# 可以通过set()来将序列和字典转换为集合
s = set([1,2,3,4,5,1,1,2,3,4,5])
s = set('hello')
s = set({'a':1,'b':2,'c':3}) # 使用set()将字典转换为集合时，只会包含字典中的键

# 创建集合
s = {'a' , 'b' , 1 , 2 , 3 , 1}

# 使用in和not in来检查集合中的元素
print('c' in s)

# 使用len()来获取集合中元素的数量
print(len(s))

# add() 向集合中添加元素
s.add(10)
s.add(30)

# update() 将一个集合中的元素添加到当前集合中
#   update()可以传递序列或字典作为参数，字典只会使用键
s2 = set('hello')
s.update(s2)
s.update((10,20,30,40,50))
s.update({10:'ab',20:'bc',100:'cd',1000:'ef'})

# {1, 2, 3, 100, 40, 'o', 10, 1000, 'a', 'h', 'b', 'l', 20, 50, 'e', 30}
# pop()随机删除并返回一个集合中的元素
result = s.pop()

# remove()删除集合中的指定元素
s.remove(100)
s.remove(1000)

# clear()清空集合
s.clear()

# copy()对集合进行浅复制

# print(result)
print(s , type(s))

集合运算

# 在对集合做运算时，不会影响原来的集合，而是返回一个运算结果
# 创建两个集合
s = {1,2,3,4,5}
s2 = {3,4,5,6,7}

# & 交集运算
result = s & s2 # {3, 4, 5}

# | 并集运算
result = s | s2 # {1,2,3,4,5,6,7}

# - 差集
result = s - s2 # {1, 2}

# ^ 异或集 获取只在一个集合中出现的元素
result = s ^ s2 # {1, 2, 6, 7}

# <= 检查一个集合是否是另一个集合的子集
# 如果a集合中的元素全部都在b集合中出现，那么a集合就是b集合的子集，b集合是a集合超集
a = {1,2,3}
b = {1,2,3,4,5}

result = a <= b # True
result = {1,2,3} <= {1,2,3} # True
result = {1,2,3,4,5} <= {1,2,3} # False

# < 检查一个集合是否是另一个集合的真子集
# 如果超集b中含有子集a中所有元素，并且b中还有a中没有的元素，则b就是a的真超集，a是b的真子集
result = {1,2,3} < {1,2,3} # False
result = {1,2,3} < {1,2,3,4,5} # True

# >= 检查一个集合是否是另一个的超集
# > 检查一个集合是否是另一个的真超集
print('result =',result)