Python 基础

Python 简介

2.  程序员：
   

程序设计人员。

2. 程序：

一组计算机能识别和执行的指令，是实现某种需求的软件。

3. 程序员：

程序设计人员。

程序：

一组计算机能识别和执行的指令，是实现某种需求的软件。

操作系统：

管理和控制计算机软件与硬件资源的程序；

隔离不同硬件的差异，使开发程序简单化。

1. 操作系统：

管理和控制计算机软件与硬件资源的程序；

隔离不同硬件的差异，使开发程序简单化。

例如，Windows，Linux，Unix。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JefIYOgn-1573646222722)(/home/tarena/1909/笔记/图/day01/计算机基本结构.jpg)]

2. 硬件：

主板–计算机的主要电路系统。

CPU --主要负责执行程序指令，处理数据。

硬盘–持久化存储数据的记忆设备，容量大，速度慢。

内存–临时存储数据的记忆设备，容量小，速度快。

IO设备–键盘、鼠标、显示器。

Python 定义

是一个免费、开源、跨平台、动态、面向对象的编程语言。

Python程序的执行方式

交互式

在命令行输入指令，回车即可得到结果。

1. 打开终端

2. 进入交互式：python3

3. 编写代码：print(“hello world”)

4. 离开交互式：exit()

文件式

将指令编写到.py文件，可以重复运行程序。

1. 编写文件。

2. 打开终端

3. 进入程序所在目录：cd 目录

4. 执行程序： python3 文件名

Linux常用命令

1. pwd：查看当前工作目录的路径

2. ls：查看指定目录的内容或文件信息

3. cd：改变工作目录（进入到某个目录）

练习：

2. 在指定目录创建python文件.

–目录：/home/tarena/1908/month01

–文件名：exercise01.py

2. 在文件中写入：print(“你好，世界!”)

\3. 运行python程序

执行过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LCVhbSbX-1573646222724)(/home/tarena/.config/Typora/typora-user-images/1570753670995.png)]

计算机只能识别机器码(1010)，不能识别源代码(python)。

1. 由源代码转变成机器码的过程分成两类：编译和解释。

2. 编译：在程序运行之前，通过编译器将源代码变成机器码，例如：C语言。

– 优点：运行速度快

– 缺点：开发效率低，不能跨平台。

​ 3.解释：在程序运行之时，通过解释器对程序逐行翻译，然后执行。例如Javascript

– 优点：开发效率高，可以跨平台；

– 缺点：运行速度慢。

​ 4.python是解释型语言，但为了提高运行速度，使用了一种编译的方法。编译之后得到pyc文件，存储了字节码（特定于Python的表现形式，不是机器码）。

源代码 – 编译 --> 字节码 – 解释 --> 机器码

|————1次———|

解释器类型

2. CPython（C语言开发)

3. Jython (java开发)

4. IronPython (.net开发)

数据基本运算

代码：

"""

### 汇率转换器

"""

``#获取数据

usd = input("请输入美元：")

#逻辑计算

result = float(usd) * 7.1243

#显示结果

print("人民币是：" + str(result))

pycharm常用快捷键

2. 移动到本行开头：home键

3. 移动到本行末尾：end键盘

4. 注释代码：ctrl + /

5. 复制行：ctrl +d

6. 选择列：鼠标左键 + alt

7. 移动行：shift + alt + 上下箭头

8. 智能提示：ctrl + space

9. 代码格式化：ctrl+alt+l

注释

给人看的，通常是对代码的描述信息。

2. 单行注释：以#号开头。

3. 多行注释：三引号开头，三引号结尾。

函数

函数代码：

"""
    函数
        结果 = 函数名(输入的信息)
"""
# 1. print
# 字面意思:打印/输出/显示
# 参数:需要呈现的内容
#     备注:如果是文字需要放在双引号中
# 适用性:需要显示结果
print("需要呈现的内容")

# 2. input
# 字面意思:输入  从终端到程序
# 参数:需要提示的信息
# 结果:用户实际录入的内容
# 适用性:从终端获取数据
result = input("需要提示的信息")

表示一个功能，函数定义者是提供功能的人，函数调用者是使用功能的人。

例如：

1. print(数据) 作用：将括号中的内容显示在控制台中

2. 变量 = input(“需要显示的内容”) 作用：将用户输入的内容赋值给变量

变量

变量内存图：

变量交换思想：

1. 定义：关联一个对象的标识符。

2. 命名：必须是字母或下划线开头，后跟字母、数字、下划线。

​ 不能使用关键字(蓝色)，否则发生语法错误：SyntaxError: invalid syntax。

​ 3.建议命名：字母小写，多个单词以下划线隔开。程序员：

​ 程序设计人员。

​ 程序：

一组计算机能识别和执行的指令，是实现某种需求的软件。

操作系统：

管理和控制计算机软件与硬件资源的程序；

隔离不同硬件的差异，使开发程序简单化。

​ class_name

4.创建一个变量或改变一个变量关联的数据。

5.变量名 = 数据

​ 变量名1 = 变量名2 = 数据

​ 变量名1, 变量名2, = 数据1, 数据2

变量代码：

"""
    变量
        程序运行在哪? --- 内存
        程序处理什么? --- 数据
        变量:存储数据的
        语法:
            变量名称 = 数据
        = 赋值号: 右边 给 左边
    练习:exercise01.py
    练习:exercise02.py
    练习:exercise03.py
"""

创建变量age关联数据18

age = 18

修改变量age存储的数据地址

age = 100

访问变量存储的数据地址

print(age)

将变量age存储的数据地址 复制一份 给新变量number

number = age

删除变量age

del age

同时创建多个变量

count, id = 10, 901

同时为多个变量赋值

num01 = num02 = num03 = 888

del 语句

2. 语法:

del 变量名1, 变量名2

​ 2.作用：

用于删除变量,同时解除与对象的关联.如果可能则释放对象。

​ 3.自动化内存管理的引用计数：

每个对象记录被变量绑定(引用)的数量,当为0时被销毁。

核心数据类型

数据类型代码知识点：

"""
    数据类型
        变量没有类型
        变量关联的对象有类型
"""
# 1. 空值类型
# --表示不存在的特殊对象。
number = None
# -- 占位和解除与对象的关联。
id = 101
id = None

# 2. 整形(整数)int
# 十进制(逢十进一)
# 0123456789 10  11  12  ... 2?  3? ... 99  100
number = 10

# 二进制(逢二进一)0 1 10
number = 0b10
print(number)# 以十进制显示2
# 八进制(逢八进一)0 1 2 3 4 5 6 7 10
number = 0o10
print(number)# 以十进制显示8
# 十六进制(逢十六进一)0 1 2 .. 9  a(10) f(15)  10
number = 0x10
print(number)# 以十进制显示16

# 3. 浮点型 float
number = 1.5
number = 0.00005

print(number)# 5e-05

# 4. 字符串str
name = "张无忌"
str01 = "1" + "2" # 字
print(str01)# 12
str01 = 1 + 2# 数   支持数学运算
print(str01)# 3

# 5. 复数 complex
# 实部  虚部 j
number = 1 + 1j
number = 1j
print(type(number))

2. 在python中变量没有类型，但关联的对象有类型。

3. 通过type函数可查看。

空值对象 None

2. 表示不存在的特殊对象。

3. 作用：占位和解除与对象的关联。

整形int

2. 表示整数，包含正数、负数、0。

如： -5, 100, 0

​ 2.字面值：

十进制：5

二进制：0b开头，后跟1或者1

八进制：0o开头，后跟0~7

十六进制：0x开头，后跟0_9,AF,a~f

浮点型float

2. 表示小数，包含正数、负数，0.0)。

3. 字面值：

小数：1.0 2.5

科学计数法：e/E (正负号) 指数

​ 1.23e-2 (等同于0.0123)

​ 1.23456e5(等同于123456.0)

字符串str

​ 是用来记录文本信息(文字信息)。

​ 字面值：双引号

复数complex

由实部和虚部组成的数字。

虚部是以j或J结尾。

字面值： 1j 1+1j 1-1j

布尔bool

运算符代码：

"""
    bool
    比较运算符 >  <  ==  !=  >=  <=
    逻辑运算符
    练习:exercise09.py
"""
# 1.  命题:带有判断性质的陈述句.
#  你是个美女.
#  如果成立 True  不成立 False

# 2. 比较运算符
#  比较数值大小 , 结果是bool类型.
number01 = 8
number02 = "8"
print(number01 == number02)  # 8  == "8"  --> Flase

# 3. 逻辑运算符
# 判断2个bool值关系的
# 与 and   一假俱假   表达"并且"关系(所有条件必须都满足)
print(True and True)  # True
print(False and True)  # False
print(True and False)  # False
print(False and False)  # False

# 或 or   一真俱真   表达"或者"关系(有一个就行)
print(True or True)  # True
print(False or True)  # True
print(True or False)  # True
print(False or False)  # False

# 非  取反
print(not True)  # False

用来表示真和假的类型

True 表示真(条件满足或成立)，本质是1

False 表示假(条件不满足或不成立)，本质是0

数据类型转换

数据类型转换代码知识点：

"""
    数据类型转换
     input 结果是字符串
"""
usd = "8.5+"
# str  -->  float
# 注意:字符串必须长得"像"需要转换的类型
usd = float(usd)
# float  -->  str
print("结果是:"+str(usd))

2. 转换为整形: int(数据)

3. 转换为浮点型:float(数据)

4. 转换为字符串:str(数据)

5. 转换为布尔:bool(数据)

​ 结果为False：bool(0) bool(0.0) bool(None)

​ 5.混合类型自动升级：

​ 1 + 2.14 返回的结果是 3.14

​ 1 + 3.0 返回结果是: 4.0

运算符

除法图：

算术运算符

运算符代码：

"""
    运算符
        算数运算符+  -  *  数学的除法/  地板除//  取余数%  幂运算**
        增强运算符+= -= *=  /=  //=   %=  **=
    练习:exercise04.py
    练习:exercise05.py
    练习:exercise06.py
    练习:exercise07.py
    练习:exercise08.py
"""
# 1. 算数运算符
number01 = 5
number02 = 2
print(number01 + number02)
# 5 的 2次方
print(number01 ** number02)

# 2. 增强运算符
number03 = 10
print(number03 + 5)
# 没有改变number03
print(number03)  # 10

# number03运算后又赋值给了自身
number03 += 5  # number03 = number03 + 5

​ + 加法

​ - 减法

​ × 乘法

/ 除法：结果为浮点数

// 地板除：除的结果去掉小数部分

% 求余

** 幂运算

优先级从高到低： ()

​ **

​ * / % //

​ + -

增强运算符

y += x 等同于 y = y + x

y -= x 等同于 y = y - x

y *= x 等同于 y = y * x

y /= x 等同于 y = y / x

y //= x 等同于 y = y // x

y %= x 等同于 y = y % x

y **= x 等同于 y = y * * x

比较运算符

< 小于

<= 小于等于

> 大于

>= 大于等于

== 等于

!= 不等于

返回布尔类型的值

比较运算的数学表示方式:0 <= x <= 100

逻辑运算符

逻辑运算符图：

与and

表示并且的关系，一假俱假。

示例:

​ True and True # True

​ True and False # False

​ False and True # False

False and False # False

或or

表示或者的关系，一真俱真

示例:

True or True # True

True or False # True

False or True # True

False or False # False

非 not

表示取反

例如：

not True # 返回False

not False # 返回True

短路运算

一但结果确定，后面的语句将不再执行。

# (面试题)
# 短路逻辑:
#   现象:后面的条件不会影响结果时,不再执行.
#   价值:耗时(复杂)的条件应该尽量放在前还是后
#   代码: 条件1 and 条件2 or 条件3 .....

# false and ?
# 如果and前面是false,后面的条件不会影响结果,所以不执行.
# re = 1 > 2 and print("你看见我了吗?")

# true or ?
# 如果or前面是true,后面的条件不会影响结果,所以不执行.
re = 1 < 2 or print("你看见我了吗?")

身份运算符

​ 语法:

​ x is y

​ x is not y

作用：

is 用于判断两个对象是否是同一个对象,是时返回True,否则返回False。

	is not 的作用与is相反

优先级

​ 高到低：

算数运算符

比较运算符

快捷运算符

身份运算符

逻辑运算符

语句

行

2. 物理行：程序员编写代码的行。

3. 逻辑行：python解释器需要执行的指令。

4. 建议一个逻辑行在一个物理行上。

5. 如果一个物理行中使用多个逻辑行，需要使用分号；隔开。

6. 如果逻辑行过长，可以使用隐式换行或显式换行。

隐式换行：所有括号的内容换行,称为隐式换行

​ 括号包括: () [] {} 三种

显式换行：通过折行符 \ (反斜杠)换行，必须放在一行的末尾，目的是告诉解释器,下一行也是本行的语句。

代码：

"""
    行
"""
# (建议) 3个物理行  对应3个逻辑行
a = 10
b = 20
c = a + b

# (不建议)1个物理行  对应3个逻辑行
a = 10;b = 20;c = a + b

# (代码过长)3个物理行  对应1个逻辑行
a = 1 + 2 + \
    3 + 4 + 5 \
    + 6 + 6

a = 1 + (2 +
         3 + 4 + 5
         + 6) + 6

pass 语句

通常用来填充语法空白。

选择语句

If elif else 语句

2. 作用:

​ 让程序根据条件选择性的执行语句。

​ 2.语法:

"""
    选择语句
    练习:exercise01.py ~ exercise06.py
"""

sex = input("请输入性别:")
# 如果 变量sex 存储的数据等于"男"
if sex == "男":
    # 缩进:4个空格,不是Tab键盘(但是开发都用Tab键)
    print("您好,先生!")
elif sex == "女":  # 否则  互斥
    print("您好,女士!")
else:
    print("性别未知")

# 调试:让程序中断,逐语句执行.
#   目的:审查程序执行过程  --- F7
#       查看变量取值  --- Debugger 面板
#   解决:程序中的错误
#   步骤:
#       1. (在可能出错的代码)加断点
#       2. 调试运行Debug
#       3. F7 逐语句执行
#       4. 停止调试Ctrl + F2

​ if 条件1:

​ 语句块1

​ elif 条件2:

​ 语句块2

​ else:

​ 语句块3

2. 说明:

​ elif 子句可以有0个或多个。

​ else 子句可以有0个或1个，且只能放在if语句的最后。

if 语句的真值表达式

代码：

"""
    if 真值表达式

        if 变量:
            如果变量指向的数据有值,则满足条件.

        if 变量 != 0:
        if 变量 != 0.0:
        if 变量 != "":

    if 条件表达式
        变量 = 满足条件的值 if 条件 else 不满足条件的值

    练习:exercise07.py
"""
print(bool(1))
print(bool(62626))
print(bool(-34324))
print(bool(0))  # false

print(bool("a"))
print(bool("你好"))
print(bool(" "))
print(bool(""))  # false

print(bool(0.1))
print(bool(0.0))  # false

# 1. if 真值表达式
str_input = input("请输入:")
# 如果字符串有数据则处理
# if str_input != "":
if str_input:
    print("处理")

#  2. if 条件表达式
sex = input("请输入:")
# 根据条件,给变量赋值
# if sex == "男":
#     value = 1
# else:
#     value = -1

value = 1 if sex == "男" else -1
print(value)

if 100:

​ print(“真值”)

等同于

if bool(100):

​ print(“真值”)

条件表达式

语法：变量 = 结果1 if 条件 else 结果2

作用：根据条件(True/False) 来决定返回结果1还是结果2。

循环语句

while: 根据条件重复执行

for:遍历可迭代对象中的元素

​ 预订次数

while语句

代码：

"""
    while 循环 计数
    15:50
"""
count = 0  # 从哪里开始
while count < 5:  # 5 < 5    到哪里结束
    print(count)  # 0 1 2 3 4
    count += 1  # 跨度

1. 作用:

可以让一段代码满足条件，重复执行。

​ 2.语法:

while 条件:

​ 满足条件执行的语句

​ else:

​ 不满足条件执行的语句

random_number = random.randint(1,100)
count = 0
while count < 3:
    count += 1
    input_number = int(input("请输入:"))
    if input_number > random_number:
        print("大了")
    elif input_number < random_number:
        print("小了")
    else:
        print("猜对了,总共猜了"+str(count)+"次.")
        break
else:# 如果循环条件不满足,才执行else语句
    print("你失败了")

​ 3.说明:

​ else子句可以省略。

​ 在循环体内用break终止循环时,else子句不执行。

for 语句

"""
    for  for
"""

# 外层循环控制行
for r in range(3):#     0        1      2
    # 内层循环控制列
    for c in range(4):#0123    0123    0123
        print("$",end = " ")
    print()

1. 作用:

​ 用来遍历可迭代对象的数据元素。

可迭代对象是指能依次获取数据元素的对象，例如：容器类型。

​ 2.语法:

​ for 变量列表 in 可迭代对象:

​ 语句块1

​ else:

​ 语句块2

​ 3.说明:

​ else子句可以省略。

​ 在循环体内用break终止循环时,else子句不执行。

range 函数

# range 整数生成器
# range(结束)
# range(开始,结束)
# range(开始,结束,间隔)
# 不包含结束值
for item in range(5,10,2):# 0 1 2
    print(item)

１．作用:

​ 用来创建一个生成一系列整数的可迭代对象(也叫整数序列生成器)。

2. 语法:

​ range(开始点，结束点，间隔)

​ 3.说明:

函数返回的可迭代对象可以用for取出其中的元素

返回的数字不包含结束点

开始点默认为0

间隔默认值为1

跳转语句

break 语句

2. 跳出循环体，后面的代码不再执行。

3. 可以让while语句的else部分不执行。

continue 语句

# 需求:累加1--100之间能被5整除的数字
# 1 + 2+ 3+ ... 100
# sum_value = 0
# for item in range(1, 101):
#     # 满足条件则累加
#     if item % 5 == 0:
#         sum_value += item
# print(sum_value)

sum_value = 0
for item in range(1, 101):
    # 不满足条件则跳过
    if item % 5 != 0:
        continue
    sum_value += item
print(sum_value)

跳过本次，继续下次循环。

容器类型

通用操作

"""
    字符串常用操作
    练习:exercise09.py
"""

# 1. 数学运算
# -- 拼接
name = "悟空"
name += "大圣"
print(name)  # 悟空大圣

# -- 重复
name = "八戒"
name *= 3
print(name)

# 比较
str01 = "axy"
str02 = "acd"
# 依次比较两个容器中元素,一但不同则返回比较结果。
print(str01 > str02)

# 成员运算
str03 = "我在花果山."
print("在花" in str03)

# 索引 -- 单个
print(str03[1])  # 在
print(str03[-1])  # .
print(str03[2])  # 花
print(str03[-4])  # 花
# 特别注意:索引不能越界
# print(str03[10])#  IndexError: string index out of range
# print(str03[-8])#  IndexError: string index out of range
# 切片 -- 多个
print(str03[2:5:1])  # 花果山
# 开始索引/结束索引可以不写
print(str03[:2])  # 我在
print(str03[-2:])  # 山.
print(str03[:])  # 我在花果山.
print(str03[::-1])  # .山果花在我
print(str03[-4::-1])  # 花在我
print(str03[::2])  # 我花山
print(str03[1:-1])  # 在花果山
print(str03[-2:2])  # 空
print(str03[1:1])  # 空
print(len(str03))  # 总数

数学运算符

1. +：用于拼接两个容器

2. +=：用原容器与右侧容器拼接,并重新绑定变量

3. *：重复生成容器元素

4. *=：用原容器生成重复元素, 并重新绑定变量

5. < <= > >= == !=：依次比较两个容器中元素,一但不同则返回比较结果。

成员运算符

1. 语法：

   数据 in 序列

数据 not in 序列

​ 2 .作用：

 	 如果在指定的序列中找到值，返回bool类型。

索引index

1. 作用：定位单个容器元素

2. 语法：容器[整数]

3. 说明：

正向索引从0开始，第二个索引为1，最后一个为len(s)-1。

反向索引从-1开始,-1代表最后一个,-2代表倒数第二个,以此类推,第一个是-len(s)。

切片slice

1. 作用：

定位多个容器元素。

​ 2. 语法：

容器[(开始索引):(结束索引)(:(步长))]

​ 3. 说明：

小括号()括起的部分代表可省略

结束索引不包含该位置元素

步长是切片每次获取完当前元素后移动的偏移量

内建函数

1. len(x) 返回序列的长度

2. max(x) 返回序列的最大值元素

3. min(x) 返回序列的最小值元素

4. sum(x) 返回序列中所有元素的和(元素必须是数值类型)

字符串 str

"""
    str
"""
# 1. 不可变
# 如果改变,很可能破坏其他对象的内存空间.
name = "悟空"
name = "孙悟空"
name = name + "大圣"
# 创建新字符串对象,替换变量存储的地址.
print(name)  # 孙悟空

定义

由一系列字符组成的不可变序列容器，存储的是字符的编码值。

编码

# 编码
# 字 --> 数
print(ord("a"))

# 数 --> 字py
print(chr(100))

2. 字节byte：计算机最小存储单位，等于8 位bit.

3. 字符：单个的数字，文字与符号。

4. 字符集(码表)：存储字符与二进制序列的对应关系。

5. 编码：将字符转换为对应的二进制序列的过程。

6. 解码：将二进制序列转换为对应的字符的过程。

7. 编码方式：

–ASCII编码：包含英文、数字等字符，每个字符1个字节。

–GBK编码：兼容ASCII编码，包含21003个中文；英文1个字节，汉字2个字节。

–Unicode字符集：国际统一编码，旧字符集每个字符2字节，新字符集4字节。

–UTF-8编码：Unicode的存储与传输方式，英文1字节，中文3字节。

相关函数

2. ord(字符串):返回该字符串的Unicode码。

3. chr(整数):返回该整数对应的字符串。

字面值

"""
    字符串字面值
    练习:exercise08.py
"""

# 单引号
str01 = 'a'
# 双引号
str01 = "a"
# 三引号 -- 可见即所得
str01 = """
   a
        lasdnflasdf
 afasdf
adf
"""
str01 = '''a'''

# 1.	单引号内的双引号不算结束符
# 2.	双引号内的单引号不算结束符
str02 = '我叫"qtx".'
str02 = "我叫'qtx'."
str02 = '''我叫'q't"x".'''

# 转义符: 改变原始字符串含义的特殊字符
# \"    \'     \t 水平制表格   \n 换行   \\   r"原始字符串"
str03 = "我叫\"qtx\"."
str04 = "我\t叫苏大强."
str04 = "我\n叫苏大强."
url = "C:\\arogram Files\\bommon Files\cervices"
url = r"C:\arogram Files\bommon Files\cervices"
print(url)

# 在字符串中插入变量
name = "悟空"
age = 28
score = 95.59
# 字符串拼接
print("我叫" + name + ",年龄是" + str(age) + ",成绩是" + str(score) + ".")
# 占位符/格式化字符串
print("我叫%s,年龄是%d,成绩是%.1f." % (name, age, score))

单引和双引号的区别

1. 单引号内的双引号不算结束符

2. 双引号内的单引号不算结束符

三引号作用

1. 换行会自动转换为换行符\n

2. 三引号内可以包含单引号和双引号

3. 作为文档字符串

转义字符

1. 改变字符的原始含义。

\’ \” \””” \n \ \t \0 空字符

2. 原始字符串：取消转义。

    	a = r”C:\newfile\test.py”
   

字符串格式化

1. 定义：

生成一定格式的字符串。

2. 语法：

字符串%(变量)

“我的名字是%s,年龄是%s” % (name, age)

3. 类型码：

%s 字符串 %d整数 %f 浮点数

列表 list

"""
    列表内存图
    15:25
"""

# list01 列表类型的引用(地址)
list01 = ["张无忌", "张翠山"]
# 将列表引用赋值给变量list02
list02 = list01
# 修改的是列表第一个元素
list01[0] = "无忌哥哥"
print(list02[0])  # "无忌哥哥"

list01 = ["张无忌", "张翠山"]
# 通过切片获取数据时,会创建新容器.
list02 = list01[:]
list01[0] = "无忌哥哥"
print(list02[0])  # 张无忌

list01 = ["张无忌", "张翠山"]
list02 = list01
# 遍历列表["张三丰","赵敏"]中元素,赋值给list01指向的列表中(第二个位置)
list01[1:] = ["张三丰", "赵敏"]
print(list02)  # ['张无忌', '张三丰', '赵敏']

list01 = ["张无忌", "张翠山"]
list02 = list01
# 修改的是变量list01存储的地址
list01 = "张三丰"
print(list02)

# 将列表作为列表的元素
list01 = [["张无忌", "赵敏"], "张翠山"]
list02 = list01
# 修改列表第一个元素的第一个元素
list01[1][0] = "周芷若"
print(list02)

"""
    is 身份运算符
"""
list01 = [100, 200]
list02 = [100, 200]
# 判断内容
print(list01 == list02)  # True
# id(list01) == id(list02)
print(list01 is list02)  # False

list01 = [100, [200, 300]]
list02 = [100, [200, 300]]
print(list01 == list02)  # True

定义

由一系列变量组成的可变序列容器。

基础操作

"""
    列表基础操作  list
    练习:exercise01.py
"""

# 1. 创建
list01 = []
list01 = [3,"a",45,False,676]

lis02 = list()
# list(可迭代对象)
# str 不可变 --> list 可变
list02 = list("abcde")
# 整数生成器 --> list
list02 = list(range(5))#

# 2. 增加
# -- 追加
list02.append("A")
# -- 插入(位置,元素)
list02.insert(1,"孙悟空")

# 3. 获取
# -- 索引
# 最后一个
print(list02[-1])
# print(list02[500])# 小心越界
# -- 切片
print(list02)
# 后三个
print(list02[-3:])
# 前三个
print(list02[:3])
# -- 循环
# 正向
# for item in list02:
#     print(item)
# 反向
# for i in range(len(list02)-1,-1,-1):
#     print(list02[i])

# 4. 修改
#  [0, '孙悟空', 1, 2, 3, 4, 'A']
# -- 索引
list02[1] = "齐天大圣"
list02[-1] = "a"
# -- 切片
# 原理: 遍历右侧的可迭代对象,将每个元素依次赋值给左边定位的元素
#      温馨提示:右侧必须是可迭代对象
list02[:3] = "abc"
list02[:0] = "asdfhs"
#" 1asdfhs"
print(list02)
# -- 循环
# for i in range(len(list02)):
#     list02[i] = 0

# 5. 删除
# -- 根据元素删除
list02.remove("a")
# 删除最后一个元素
# del list02[-1]
print(list02)
del list02[::2]
print(list02)

1. 创建列表：

列表名 = []

列表名 = list(可迭代对象)

2. 添加元素：

列表名.append(元素)

列表.insert(索引，元素)

3. 定位元素：

列表名[索引] = 元素

变量 = 列表名[索引]

变量 = 列表名[切片] # 赋值给变量的是切片所创建的新列表

列表名[切片] = 容器 # 右侧必须是可迭代对象，左侧切片没有创建新列表。遍历列表：

正向：

for 变量名 in 列表名:

	变量名就是元素

	反向：

for 索引名 in range(len(列表名)-1,-1,-1):

	列表名[索引名]就是元素

4. 删除元素：

列表名.remove(元素)

del 列表名[索引或切片]

深拷贝和浅拷贝

浅拷贝：复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程。

深拷贝：复制整个依懒的变量。

"""
    浅拷贝:复制一层
    深拷贝:复制整个依赖的变量
        好处:深拷贝后的数据与之前的数据互补影响.
        缺点:占用内存过大
"""
list01 = [500, [600, 700]]
# list02 = list01[:]
list02 = list01.copy()  # 浅拷贝
list01[1][0] = "六百"
print(list02)

# 创建一个深拷贝的工具
import copy

list01 = [500, [600, 700]]
# 深拷贝
list02 = copy.deepcopy(list01)
list01[1][0] = "六百"
print(list02)

列表VS字符串

2. 列表和字符串都是序列,元素之间有先后顺序关系。

3. 字符串是不可变的序列,列表是可变的序列。

4. 字符串中每个元素只能存储字符,而列表可以存储任意类型。

5. 列表和字符串都是可迭代对象。

6. 函数：

将多个字符串拼接为一个。

result = “连接符”.join(列表)

将一个字符串拆分为多个。

列表 = “a-b-c-d”.split(“分隔符”)

"""
    list --> str
    练习:exercise01.py
"""
list01 = ["a", "b", "c"]
# 结果 = 连接符.joint(列表)
result = "+".join(list01)
print(result)

# 需求:根据某些逻辑,拼接字符串.
# 0 1 2 3 4 5...9
"""
str_result = ""
for item in range(10):
    # "0" + "1"  --> "01"
    # 每次循环,都会产生一个垃圾
    # (变量str_result不断指向新对象)
    str_result += str(item)
print(str_result)
"""

# 重点:让可变对象,负责拼接元素.
list_temp = []
for item in range(10):
    list_temp.append(str(item))
str_result = "".join(list_temp)
print(str_result)

列表推导式

"""
    列表推导式嵌套
    17:00
"""
list01 = ["香蕉", "苹果", "哈密瓜"]
list02 = ["雪碧", "可乐", "咖啡", "牛奶"]
# 全排列
# list_result = []
# for r in list01:
#     for c in list02:
#         list_result.append(r + c)
list_result = [r + c for r in list01 for c in list02]
print(list_result)

1. 定义：

使用简易方法，将可迭代对象转换为列表。

2. 语法：

变量 = [表达式 for 变量 in 可迭代对象]

变量 = [表达式 for 变量 in 可迭代对象 if 条件]

3. 说明:

如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。

"""
    str --> list
"""

# 一个字符串表达多个信息
str_names = "张无忌_翠山_张三丰"
list_result = str_names.split("_")
print(list_result)

"""
    列表推导式
    练习:exercise03.py
    10:18
"""

list01 = [4,5,6,7,9,8]
# list02 = []
# for item in list01:
#     if item % 2:
#         list02.append(item)
list02 = [item for item in list01 if item % 2]
# list02 = []
# for item in list01:
#     list02.append(item ** 2)
list02 = [item ** 2 for item in list01]

列表推导式嵌套

1. 语法：

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

2. 传统写法：

result = []

for r in ["a", "b", "c"]:

​ for c in ["A", "B", "C"]:

​ result.append(r + c)

3. 推导式写法：

result = [r + c for r in list01 for c in list02]

元组 tuple

定义

1. 由一系列变量组成的不可变序列容器。

2. 不可变是指一但创建，不可以再添加/删除/修改元素。

基础操作

2. 创建空元组：

元组名 = ()

元组名 = tuple()

2. 创建非空元组：

元组名 = (20,)

​ 元组名 = (1, 2, 3)

元组名 = 100,200,300

元组名 = tuple(可迭代对象)

3. 获取元素：

变量 = 元组名[索引]

变量 = 元组名[切片] # 赋值给变量的是切片所创建的新列表

4. 遍历元组：

   正向：

   for 变量名 in 列表名:

   变量名就是元素
   
   反向：
   

   for 索引名 in range(len(列表名)-1,-1,-1):

   元组名[索引名]就是元素
   

"""
    元组 tuple
        按需分配
    练习:exercise04.py
    练习:exercise05.py
"""

# 1. 创建
# -- (元素)
tuple01 = (34, "45", True)
# 创建空元组
tuple01 = ()
# 创建具有一个元素的元组(必须在元素后增加逗号)
tuple01 = ("a",)
print(tuple01)

# -- tuple(可迭代对象)
tuple02 = tuple(range(10, 20))
print(tuple02)

# 2. 获取
# -- 索引
print(tuple02[0])
print(tuple02[-1])
# print(tuple02[20]) # 索引不能越界

# -- 切片
print(tuple02[:5])  # 切片会创建新元组
print(tuple02[:25])  # 越界不会报错

# -- 循环
# 获取每一个元素
# for item in tuple02:
#     print(item)# 元素

# 倒序获取每一个元素
for i in range(len(tuple02) - 1, -1, -1):
    # print(i)# 索引
    print(tuple02[i])

# 通用操作
tuple03 = ("a", "b")
tuple03 += ("c",)
print(tuple03) # 累加后的元素是新元组('a', 'b', 'c')

v01,v02,v03 = ("a","b","c")
print(v01)
print(v02)
print(v03)

作用

2. 元组与列表都可以存储一系列变量，由于列表会预留内存空间，所以可以增加元素。

3. 元组会按需分配内存，所以如果变量数量固定，建议使用元组，因为占用空间更小。

4. 应用：

变量交换的本质就是创建元组：x, y = （y, x ）

格式化字符串的本质就是创建元祖：“姓名:%s, 年龄:%d” % (“tarena”, 15)

字典 dict

定义

1. 由一系列键值对组成的可变散列容器。

2. 散列：对键进行哈希运算，确定在内存中的存储位置，每条数据存储无先后顺序。

3. 键必须惟一且不可变(字符串/数字/元组)，值没有限制。

基础操作

1. 创建字典：

字典名 = {键1：值1，键2：值2}

字典名 = dict (可迭代对象)

2. 添加/修改元素：

语法:

​ 字典名[键] = 数据

说明:

​ 键不存在，创建记录。

​ 键存在，修改值。

3. 获取元素：

变量 = 字典名[键] # 没有键则错误

4. 遍历字典：

   for 键名 in 字典名:

   字典名[键名]
   

for 键名,值名 in 字典名.items():

语句

5. 删除元素：

del 字典名[键]

"""
    字典
    练习:exercise06.py
    练习:exercise07.py
    练习:exercise08.py
"""

# 1. 创建
dict01 = {}
dict01 = {"101": "qtx", "102": "lzmly", "103": "wk"}

dict02 = dict([("a", "b"), ("c", "d")])

# ('101', '102', '103')
tuple01 = tuple(dict01)

# 2. 添加元素
# 如果添加的键已经存在,则修改值.
dict01["104"] = "zwj"
# 判断字典中是否存在某个键
print("104" in dict01)

# 3. 修改元素
dict01["104"] = "zsf"

# 4. 获取元素
# -- 通过键key 获取值value
print(dict01["104"])
if "105" in dict01:
    print(dict01["105"])

# -- 循环
#      遍历字典,获取key.
for key in dict01:
    print(key)
    # print(dict01[key])

#      遍历字典,获取value.
for value in dict01.values():
    print(value)

#      遍历字典,获取key同时获取value.
for k, v in dict01.items():
    print(k)  # key
    print(v)  # value

# 5. 删除元素
del dict01["101"]

# 根据条件,删除字典中的记录.
# 不能遍历字典同时删除字典
# 解决:遍历元组(所有的键)删除字典
tuple_key = tuple(dict01)
for item in tuple_key:
    # if item    dict01[item]
    del dict01[item]

# 删除全部元素
dict01.clear()
print(dict01)

字典推导式

1. 定义：

使用简易方法，将可迭代对象转换为字典。

2. 语法:

​ {键:值 for 变量 in 可迭代对象}

​ {键:值 for 变量 in 可迭代对象 if 条件}

"""
    字典推导式
    练习:exercise01.py
    练习:exercise02.py
    11:05
"""

#  key : 0 1 2 3 .. 9   --> value: 键的平方
# dict01 = {}
# for item in range(10):
#     dict01[item] = item ** 2
dict01 = {item: item ** 2 for item in range(10)}
# dict01 = {}
# for item in range(10):
#     if item % 2 !=0:
#         dict01[item] = item ** 2
dict01 = {item: item ** 2 for item in range(10) if item % 2 != 0}

字典 VS 列表

"""
    字典:
        优点:根据key定位value速度最快
             # 为值提供了键,代码可读性略高."name":张三 "score":100
        缺点:占用内存/无序(不能使用索引和切片)
    列表:
        优点:有序(能使用索引和切片)
                # 相对节省内存
        缺点:查找速度相对慢一些
             # 通过索引获取数据,如果信息过多,代码可读略差
    适用性:如果侧重于读写速度,使用字典
                      方式,使用列表
    例如:
        字典内嵌列表
                {
                    "悟空":[24,100,"男"],
                    "八戒":[26,0,"男"],
                }
         字典内嵌字典
                {
                    "悟空":{age":24,"score":100,"sex":"男"},
                    "八戒":{"age":28,"score":0,"sex":"男"},
                }
         列表内嵌字典
                [
                    {"name":"悟空",age":24,"score":100,"sex":"男"},
                    {"name":"八戒","age":28,"score":0,"sex":"男"},
                ]
"""

1. 都是可变容器。

2. 获取元素方式不同,列表用索引,字典用键。

3. 字典的插入,删除,修改的速度快于列表。

4. 列表的存储是有序的,字典的存储是无序的。

集合 set

定义

1. 由一系列不重复的不可变类型变量(元组/数/字符串)组成的可变散列容器。

2. 相当于只有键没有值的字典(键则是集合的数据)。

基础操作

"""
    集合
        特点:去重复/数学运算
    练习:exercise04.py
"""

# 1. 创建
set01 = {34, 4, 5, 456, 7, 456}
# 空集合
# set01 = {}# 这是字典
set02 = set()

# 需求:对列表去重(顺序会捣乱)
list01 = [3, 2, 2, 2, 22, 2, 2, 5]
set02 = set(list01)
list01 = list(set02)

# 2. 添加
set02.add("a")
set02.add("b")

# 3. 获取
# -- 不能定位元素
# -- 循环获取全部
for item in set02:
    print(item)

# 4. 删除
set02.remove("a")
print(set02)

# 5. 数学运算
s01 = {1,2,3}
s02 = {2,3,4}
# 交集 & 2 3
print(s01 & s02)

# 并集   {1, 2, 3, 4}
print(s01 | s02)

# 补集
# 对称补集
print(s01 ^ s02)# {1, 4}
#
print(s01 - s02)# {1}
print(s02 - s01)# {4}

# 子集  超集
s03 = {2,3}
print(s03 < s01)

1. 创建空集合：

集合名 = set()

集合名 = set(可迭代对象)

2. 创建具有默认值集合：

集合名 = {1, 2, 3}

集合名 = set(可迭代对象)

3. 添加元素：

集合名.add(元素)

4. 删除元素：

集合名.discard(元素)

运算

2. 交集&：返回共同元素。

s1 = {1, 2, 3}

s2 = {2, 3, 4}

s3 = s1 & s2  # {2, 3}

2. 并集：返回不重复元素

s1 = {1, 2, 3}

s2 = {2, 3, 4}

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

3. 补集-：返回只属于其中之一的元素

s1 = {1, 2, 3}

s2 = {2, 3, 4}

s1 - s2  # {1} 属于s1但不属于s2

补集^：返回不同的的元素

s1 = {1, 2, 3}

s2 = {2, 3, 4}

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

4. 子集<：判断一个集合的所有元素是否完全在另一个集合中

5. 超集>：判断一个集合是否具有另一个集合的所有元素

s1 = {1, 2, 3}

s2 = {2, 3}

s2 < s1  # True

s1 > s2  # True

6. 相同或不同== !=：判断集合中的所有元素是否和另一个集合相同。

   s1 = {1, 2, 3}

   s2 = {3, 2, 1}

   s1 == s2 # True

   s1 != s2 # False

子集或相同,超集或相同 <= >=

集合推导式

1. 定义：

使用简易方法，将可迭代对象转换为集合。

2. 语法:

{表达式 for 变量 in 可迭代对象}

​ {表达式 for 变量 in 可迭代对象 if 条件}

固定集合 frozenset

定义

不可变的集合。

作用

固定集合可以作为字典的键,还可以作为集合的值。

基础操作

创建固定集合：frozenset(可迭代对象)

运算

等同于set

函数 function

"""
    函数
        定义函数

        参数
"""
# 代码的重复，是万恶之源．
"""
print("直拳")
print("临门一脚")
print("摆拳")
# ....
print("直拳")
print("临门一脚")
print("摆拳")
# ....
print("直拳")
print("临门一脚")
print("摆拳")
"""
def attack():
    """
        单次攻击　
    """
    print("直拳")
    print("勾拳")
    print("临门一脚")
    print("摆拳")

# 形参：　count　数量
def attack_repeat(count):
    """
        重复攻击
    :param count:ｉｎｔ类型,数量
    """
    for i in range(count):
        print("直拳")
        print("勾拳")
        print("临门一脚")
        print("摆拳")

attack()

# 实参：真实
attack_repeat(2)

pycharm相关设置

1. “代码自动完成”时间延时设置

File -> Settings -> Editor -> General -> Code Completion -> Autopopup in (ms):0

2. 快捷键：

Ctrl + P 参数信息（在方法中调用参数）

Ctrl + Q 快速查看文档

Ctrl + Alt + M 提取方法

定义

1. 用于封装一个特定的功能，表示一个功能或者行为。

2. 函数是可以重复执行的语句块, 可以重复调用。

作用

提高代码的可重用性和可维护性（代码层次结构更清晰）。

定义函数

1. 语法：

def 函数名(形式参数):

​ 函数体

2. 说明：

def 关键字：全称是define，意为”定义”。

函数名：对函数体中语句的描述，规则与变量名相同。

形式参数：方法定义者要求调用者提供的信息。

函数体：完成该功能的语句。

3. 函数的第一行语句建议使用文档字符串描述函数的功能与参数。

调用函数

1. 语法：函数名(实际参数)

2. 说明：根据形参传递内容。

"""
    参数:调用者 给 定义者 的信息
    返回值: 定义者 给 调用者 的结果
"""

# 需求:定义函数,两个数值相加.
# 要小而精,不要大而全
"""
def add():
    # 获取数据
    number_one = float(input("请输入第一个数:"))
    number_two = float(input("请输入第二个数:"))
    # 逻辑计算
    result = number_one + number_two
    # 显示结果
    print("结果是:" + str(result))

add()
"""


def add(number_one, number_two):
    # 逻辑计算
    result = number_one + number_two
    return result  # 返回  数据


number_one = float(input("请输入第一个数:"))
number_two = float(input("请输入第二个数:"))
# 变量 = 调用函数(...)
re = add(number_one, number_two)
print("结果是:" + str(re))

返回值

"""
   函数内存分配
    15:35
"""


def fun01():
    a = 100


# 调用函数,开辟内存空间(栈帧:存储在函数中定义的变量)
fun01()


# 函数执行过后,栈帧清空.

def fun02(p1):
    # 修改p1变量存储的对象地址
    p1 = 100


data01 = "悟空"
# 传递的值变量data01存储的"悟空"地址
fun02(data01)
print(data01)  # ?

1. 定义：

方法定义者告诉调用者的结果。

2. 语法：

return 数据

"""
    返回值语法
        10:30
"""

def fun01():
    print("fun01执行喽")
    # 1. 返回 数据100,  2. 退出函数
    return 100
    print("fun01又执行喽")

# 即使有返回值,调用者也可以不定义变量接受.
fun01()

def fun02():
    print("fun02执行喽")
    # 定义函数时,没有return相当于return None
    # return  None
    # return 后面没有数据,相当于return None
    return

re = fun02()
print(re)

3. 说明：

return后没有语句，相当于返回 None。

函数体没有return，相当于返回None。

可变／不可变类型在传参时的区别

1. 不可变类型参数有:

数值型(整数，浮点数,复数)

布尔值bool

None 空值

字符串str

元组tuple

固定集合frozenset

2. 可变类型参数有:

列表 list

字典 dict

集合 set

3. 传参说明：

不可变类型的数据传参时，函数内部不会改变原数据的值。

可变类型的数据传参时，函数内部可以改变原数据。

函数参数

"""
    函数参数
        实际参数
            位置实参     函数名(数据1,数据2,数据3)
                序列实参   函数名(*序列)
            关键字实参   函数名(形参名2 =数据2,形参名1 =数据1)
                字典实参   函数名(**字典)
        形式参数
            默认参数
            位置形参
                星号元组形参  函数名(*args)
            命名关键字形参
                字典形参    函数名(**kwargs)

    练习:exercise01.py
    练习:exercise02.py
    11:25
"""


# 1. 默认参数: 实参可以不提供数据(从右到左的存在)
def fun01(p1=0.0, p2="", p3=0):
    print(p1)
    print(p2)
    print(p3)


# 位置实参 + 默认形参
fun01(1)
# 关键字实参(按名字)+ 默认形参(可以传) --> 按名字随意传
fun01(p2="p2的参数")


# 2. 位置形参:实参必须提供
def fun02(p1, p2, p3):
    print(p1)
    print(p2)
    print(p3)

实参传递方式argument

位置传参

定义：实参与形参的位置依次对应。

序列传参

定义：实参用*将序列拆解后与形参的位置依次对应。

关键字传参

定义：实参根据形参的名字进行对应。

字典关键字传参

2. 定义：实参用**将字典拆解后与形参的名字进行对应。

3. 作用：配合形参的缺省参数，可以使调用者随意传参。

形参定义方式parameter

缺省参数

1. 语法：

def 函数名(形参名1=默认实参1, 形参名2=默认实参2, …):

​ 函数体

2. 说明：

缺省参数必须自右至左依次存在，如果一个参数有缺省参数，则其右侧的所有参数都必须有缺省参数。

缺省参数可以有0个或多个，甚至全部都有缺省参数。

位置形参

语法：

def 函数名(形参名1, 形参名2, …):

函数体

星号元组形参

2. 语法：

def 函数名(*元组形参名):

函数体

2. 作用：

收集多余的位置传参。

3. 说明：

一般命名为’args’

形参列表中最多只能有一个

命名关键字形参

2. 语法：

def 函数名(*, 命名关键字形参1, 命名关键字形参2, …):

函数体

def 函数名(*args, 命名关键字形参1, 命名关键字形参2, …):
函数体

2. 作用：

强制实参使用关键字传参

双星号字典形参

2. 语法：

def 函数名(**字典形参名):

函数体

2. 作用：

收集多余的关键字传参

3. 说明:

一般命名为’kwargs’

形参列表中最多只能有一个

参数自左至右的顺序

位置形参 --> 星号元组形参 --> 命名关键字形参 --> 双星号字典形参

作用域LEGB

2. 作用域：变量起作用的范围。

3. Local局部作用域：函数内部。

4. Enclosing 外部嵌套作用域 ：函数嵌套。

5. Global全局作用域：模块(.py文件)内部。

6. Builtin内置模块作用域：builtins.py文件。

变量名的查找规则

1. 由内到外：L -> E -> G -> B

2. 在访问变量时，先查找本地变量，然后是包裹此函数外部的函数内部的变量，之后是全局变量，最后是内置变量。

局部变量

1. 定义在函数内部的变量(形参也是局部变量)

2. 只能在函数内部使用

3. 调用函数时才被创建，函数结束后自动销毁

全局变量

1. 定义在函数外部,模块内部的变量。

2. 在整个模块(py文件)范围内访问（但函数内不能将其直接赋值）。

global 语句

1. 作用：

在函数内部修改全局变量。

在函数内部定义全局变量(全局声明)。

2. 语法：

global 变量1, 变量2, …

3. 说明

在函数内直接为全局变量赋值，视为创建新的局部变量。

不能先声明局部的变量，再用global声明为全局变量。

nonlocal 语句

1. 作用：

在内层函数修改外层嵌套函数内的变量

2. 语法

nonlocal 变量名1,变量名2, …

3. 说明

在被嵌套的内函数中进行使用