Python笔记

前言

Python 只是⼀个编程语⾔,在⼯作中需要结合其他的⼯具使⽤
Python + selenium web ⾃动化(功能测试转换为代码)
Python + appium 移动端(⼿机端 APP)⾃动化
Python + requests 接⼝

Python基础学习路线

变量

变量使用来储存数据的，变量必须先定义(保存数据)后使用(取出数据)，变量定义之后, 想要是使用变量中的数据, 直接使用变量名即可

定义变量

变量名 = 数据值
name = ‘小菜鸡’ # 定义一个变量 name, 存储的数据值是 小菜鸡

变量名的命名规范

1. 必须由字母 数字和下划线组成, 并且不能以数字开头
2. 不能使用 Python 中的关键字作为变量名

变量的引用

1. 在定义变量的时候 变量 = 数据值, Python 解释器会在内存中开辟两块空间
2. 变量和数据都有自己的空间
3. 日常简单理解, 将数据保存到变量的内存中, 本质是 将 数据的地址保存到变量对应的内存中
4. 变量中存储数据地址的行为 就是引用 (变量引用了数据的地址, 简单说就是变量中存储数据), 存储的地址称为 引用地址
5. 可以使用 id() 来获取变量中的引用地址(即数据的地址), 如果两个变量的 id() 获取的引用地址一样, 即代表着, 两个变量引用了同一个数据,是同一个数据
6. 只有 赋值运算符=, 可以改变变量的引用(等号左边数据的引用)
7. python 中数据的传递,都是传递的引用

数据类型

数据转换

将一种数据类型转换另一种数据类型

变量 = 要转换为的类型(原数据)
注意点: 数据类型转换,不会改变原来的数据的类型, 会生成一个新的数据类型
int（原数据） 将数据类型转化为整形
float（原数据）将数据类型转换为浮点型
str（原数据）将数据类型转换为字符型，可以转换任意类型

可变类型和不可变类型

数据类型: int float bool str list tuple dict set ​ 可变不可变是指: 数据所在的内存是否允许修改,
允许修改就是可变类型, 不允许修改就是不可变类型(不使用=, 变量引用的数据中的内容是否会变化,会变化是可变的, 不会变化是不可变的) ​
可变类型: 列表 list, 字典 dict, 集合 set 不可变类型:int float bool str tuple

常见笔试题

1. 只有 = , 可以改变引用
2. 可变类型做参数, 在函数内部, 如果不使用 = 直接修改形参的引用, 对形参进行的数据修改 会同步到实参中

局部变量

局部变量: 在函数内部(函数的缩进中)定义的变量,称为是局部变量
特点:

1. 局部变量只能在当前函数内部使用, 不能在其他函数和函数外部使用
2. 在不同函数中,可以定义名字相同的局部变量, 两者之间没有影响
3. 生存周期(生命周期, 作用范围)–> 在哪 能用
   在函数被调用的时候,局部变量被创建, 函数调用结束, 局部变量的值被销毁(删除), 不能使用
   ​
   所以函数中的局部变量的值, 如果想要在函数外部使用, 需要使用 return 关键字, 将这个值进行返回

def func1():
    num = 10  # num 就是局部变量
    print(f"func1 函数中 {num}")
​
​
def func2():
    num = 100  # 可以在不同函数中定义名字相同的局部变量,没有影响
    print(f"func2 函数中 {num}")
​
​
func1()  # 10
func2()  # 100
func1()  # 10

全局变量

定义位置: 在函数外部定义的变量, 称为是 全局变量
特点:

1. 可以在任何函数中读取(获取) 全局变量的值
2. 如何在函数中存在和全局变量名字相同的局部变量, 在函数中使用的是 局部变量的值(就近)
3. 在函数内部想要修改全局变量的引用(数据值), 需要添加 global 关键字, 对变量进行声明为全局变量
4. 生命周期
   代码执行的时候被创建, 代码执行结束,被销毁(删除)

g_num = 10  # 全局变量
​
​
def func1():
    print(f'func1 中 {g_num}')  # 在函数中可以读取全局变量的值
​
​
def func2():
    g_num = 20  # 定义局部变量, 不会影响全局变量
    print(f'func2 中 {g_num}')
​
​
def func3():
    global g_num  # 这个函数中使用的 g_num  都是全局变量, 写在函数的第一行
    g_num = 30  # 修改了全局变量
    print(f'func3 中 {g_num}')
​
​
func1()  # 10
func2()  # 20
func1()  # 10
func3()  # 30
func1()  # 30
print(g_num)   # 30

​

输入input（）

变量=input（），得到的数据类型是字符串

输出print（）

将程序中的数据或者结果打印到控制台(屏幕)

格式化输出

1.适合任意版本

• % 格式化输出占位符号
  %d 占位, 填充 整型数据 digit
  %f 占位. 填充 浮点型数据 float
  %s 占位, 填充 字符串数据 string

补充: 其实 %s 的占位符,可以填充任意类型的数据

2.python3.6后版本

• F-string( f字符串的格式化方法)
  1. 需要在字符串的前边加上 f"" 或者 F""
  2. 占位符号统一变为 {}
  3. 需要填充的变量 写在 {} 中

3.可以在任意版本中使用

• 字符串.format()
  1. 在需要使用 变量的地方使用 {} 占位
  2. ‘{}, {}, …’.format(变量, 变量, …)

运算符

运算符	描述
+	加
-	减
*	乘
/	除（结果为浮点型）
//	求商（结果为整数c）a//b=c…d
%	求余
**	幂

优先级: () > ** > * / // % > + -

判断

1.if elif else 结构
如果某个判断条件有多个, 此时建议使用 if elif else 结构来实现

if 判断条件1:
判断条件1成立,执行的代码 
elif 判断条件2:  （ 只有判断条件1不成立,才会判断 判断条件2）
判断条件2成立执行的代码 
else:
以上条件都不成立,执行的代码

2.多if结构
if之间并没有关联，无论上面的if条件成不成立，下面的if都会继续执行

if 判断条件1:
判断条件1成立,执行的代码 
if 判断条件2:  
判断条件2成立执行的代码 
if 判断条件3： 
判断条件3成立执行的代码

3.if else结构

if 判断条件:  
判断条件成立执行的代码 
else:
以上条件不成立,执行的代码

循环

while循环

例：

for循环

for循环也可以让指定的代码重复执行 (循环)
for循环可以遍历容器中的数据(
遍历: 从容器中把数据一个一个取出
容器: 可以简单理解为盒子, 盒子中可以存放很多的数据 (字符串 str, 列表 list, 元组 tuple, 字典 dict)

1.遍历容器中的数据

for 变量名 in 容器:
	重复执行的代码

2.for 做指定次数的循环

for 变量 in range(n):
    重复执行的代码

3.range() 变形
使用 for 循环获取 a 到 b 之间的数字

for 变量 in  range(a, b):
    重复的代码

1, range() 是 Python 中的函数, 作用使用可以生成 [0, n) 之间的整数, 不包含 n 的 , 一个有 n 个数字, 所以这个循环循环 n 次
2, 想让 for 循环循环多少次,n 就写几
3, 变量的值 也是每次循环从 [0, n) 取出一个值, 第一次取得是 0 ,最后一次取得是 n-1

break和 continue

break 和 continue 是 Python 中的两个关键字, 只能在循环中使用 break: 终止循环, 即代码执行遇到
break：循环不再执行,立即结束
continue: 跳过本次循环. 即代码执行遇到 continue,本次循环剩下的代码不再执行,
继续下一次循环

生成随机数

在 Python 中，可以使用内置的 random 模块来生成随机数

import random random.random() 返回一个介于 0.0 和 1.0 之间的随机小数
random.randint(a, b) 用于返回一个介于 a 和 b 之间的整数（包括 a 和 b）
random.choice(sequence) 用于从容器中随机选择一个元素

容器

容器: 也可以称为是数据序列, 或者高级数据类型, 也是 Python 中的数据类型
容器中可以存放多个数据.

字符串

定义

定义: 使用引号(单引号, 双引号, 三引号)引起来的内容就是字符串

下标

下标(索引): 就是指字符在字符串中的位置编号, 这个编号就是下标
下标作用: 可以使用下标获取字符串中某个位置的字符
语法:
字符串[下标] # 获取指定位置的字符

str=”abcdefg“
print(str[0])       a
print(str[1])       b
print(str[-1])      g
print(str1[-2])     f

len( )获取字符串长度

str=”abcdefg“
print（len(str)） 7

切片

切片: 可以获取字符串中多个字符(多个字符的下标是有规律的, 等差数列)
​

语法:
字符串[start: end: step]
start 是开始位置的下标,
end 是结束位置的下标(注意,不能取到这个位置的字符)
step 步长,等差数列的差值, 所取的相邻字符下标之间的差值,默认是 1, 可以不写

字符串的查找方法 find

字符串.find(sub_str, start, end)
作用: 在字符串中查找是否存在 sub_str 这样的字符串
sub_str: 要查找的字符串
start: 开始位置, 从哪个下标位置开始查找, 一般不写,默认是 0
end: 结束位置, 查找到哪个下标结束, 一般不写,默认是 len()

返回(代码执行之后会得到什么, 如果有返回,就可以使用变量保存): 
    1. 如果在字符串中找到了 sub_str , 返回 sub_str 第一次出现的正数下标(sub_str 中第一个字符在原字符串中的下标)
    2. 如果没有找到,返回 -1

字符串的替换方法 replace

字符串.replace(old_str, new_str, count) # 将字符串中 old_str 替换为 new_str

• old_str: 被替换的内容
• new_str: 替换为的内容
• count: 替换的次数, 一般不写,默认是全部替换
• 返回: 替换之后的完整的字符串, 注意: 原来的字符串没有发生改变

字符串的拆分 split

字符串.split(sep, maxsplit) # 将字符串按照 sep 进行分割(拆分)
​

• sep, 字符串按照什么进行拆分, 默认是空白字符(空格, 换行\n, tab键\t)
• max_split, 分割次数,一般不写, 全部分割
• 返回: 将一个字符串拆分为多个,存到列表中
• 注意: 如果 sep 不写, 想要指定分割次数 则需要按照如下方式使用 字符串.split(maxsplit=n) # n 是次数

字符串的连接 join

字符串.join(列表) # 括号中的内容主要是列表,可以是其他容器

作用: 将字符串插入到列表中每相邻的两个数据之间, 组成一个新的字符串

• 列表中的数据使用逗号隔开的
• 注意点: 列表中的数据必须都是字符串, 否则会报错

列表

列表 list, 是使用最多的一种容器(数据类型)
列表中可以存储多个数据, 每个数据之间使用逗号隔开
列表中可以存放任意类型的数据
列表支持下标，切片(列表的切片得到的是列表)，len（），使用方法和字符串中的使用方法一致,但不支持find()方法

定义

1.类实例化的方式(不常用)
1.1 定义空列表(没有任何数据的列表)
变量 = list()

 list1 = list()
 print(type(list1), list1)  # <class 'list'> []

​
1.2 类型转换 list(容器) 将其他的容器转换为列表
转换字符串会将字符串中的每个字符作为一个数据存入到列表中

list2 = list('hello')
print(type(list2), list2)  # <class 'list'> ['h', 'e', 'l', 'l', 'o']

​
2, 直接使用 [] 进行定义(常用)
2.1 定义空列表

my_list = []
print(my_list)  # []

​
2.2 定义非空列表

my_list1 = [1, '小明', 3.14, False]
print(my_list1)  # [1, '小明', 3.14, False]

查找index（）

在字符串中使用的 find 方法查找下标的,不存在返回的是 -1.
在列表中没有 find 方法, 想要查找数据的下标,使用的index() 方法 ​
列表.index(数据, start, end) 使用和 find 方法一样, 同时在字符串中也有 index方法
区别:
index() 方法,找到返回的是第一次出现的下标, 没有找到代码直接报错

统计出现的次数count（）

统计出现的次数,使用的是 count() 方法
列表.count(数据) #返回数据出现的次数
my_list = [1, 3, 5, 7, 2, 3]
​

# 找 数据 3 出现的下标
num = my_list.index(3)
print(num)  # 1
# 找 数据 4 出现的下标
# num1 = my_list.index(4)  #  代码会报错
方法一：
if 4 in my_list:
    num1 = my_list.index(4)
    print(num1)
else:
    print('不存在数据 4')
​
# my_list.count(4) 统计 数据 4 出现的次数
方法二：
if my_list.count(4) > 0:
    num1 = my_list.index(4)
    print(num1)
else:
    print('不存在数据 4')
​

添加数据的方法

1. 尾部添加(最常用)

列表.append(数据) # 将数据添加到列表的尾部 ​
返回: 返回的 None(关键字,空), 一般就不再使用 变量
来保存返回的内容 想要查看添加后的列表,需要打印的是列表

2. 指定下标位置添加

列表.insert(下标, 数据) # 在指定的下标位置添加数据, 如果指定的下标位置本来有数据, 原数据会后移 ​
返回: 返回的None(关键字,空), 一般就不再使用 变量 来保存返回的内容 想要查看添加后的列表,需要打印的是列表

3. 列表合并

列表1.extend(列表2) # 将列表 2 中的所有数据逐个添加的列表1 的尾部
返回: 返回的 None(关键字,空),一般就不再使用 变量 来保存返回的内容 想要查看添加后的列表,需要打印的是列表

​

my_list = []
print(my_list)  # []
# 1. 想列表中添加数据  郭德纲
my_list.append('郭德纲')
print(my_list)  # ['郭德纲']
​
# 2. 向列表的尾部添加 郭麒麟
my_list.append('郭麒麟')
print(my_list)  # ['郭德纲', '郭麒麟']
​
# 3. 在下标位置为 1 的位置添加数据 '岳岳
my_list.insert(1, '岳岳')
print(my_list)  # ['郭德纲', '岳岳', '郭麒麟']
​
# 4. 在下标位置为 1 的位置添加数据 于谦
my_list.insert(1, '于谦')
print(my_list)  # ['郭德纲', '于谦', '岳岳', '郭麒麟']
​
# 5. 定义新的列表 list1
list1 = ['孙越', '烧饼']
# 将 list1 中数据逐个添加到 my_list 中
my_list.extend(list1)
print(my_list)  # ['郭德纲', '于谦', '岳岳', '郭麒麟', '孙越', '烧饼']
​
# 将 list1 作为一个整体添加到 my_list
my_list.append(list1)
print(my_list)  # ['郭德纲', '于谦', '岳岳', '郭麒麟', '孙越', '烧饼', ['孙越', '烧饼']]
​

修改数据

想要修改列中的指定下标位置的数据, 使用的语法是: ​
列表[下标] = 数据 ​
注意：字符串中字符不能使用下标修改

# 定义列表
my_list = [1, 3, 5, 7]
​
# 1. 想要将下标为 1 的数据修改为 22
my_list[1] = 22
print(my_list)  # [1, 22, 5, 7]
​
# 修改最后一个位置的数据, 改为 'hello'
my_list[-1] = 'hello'
print(my_list)  # [1, 22, 5, 'hello']
​
# 2. 如果指定的下标不存在, 会报错的
# my_list[10] = 10  # 代码会报错

删除操作

在列表中删除中间的数据, 那么后面的数据会向前移动

1. 根据下标删除

列表.pop(下标) # 删除指定下标位置对应的数据

1. 下标不写,默认删除最后一个数据(常用)
2. 书写存在的下标, 删除对应下标位置的数据
   返回: 返回的删除的数据
   注意: 如果要删除的数据不存在, 会报错

2. 根据数据值删除

列表.remove(数据值) # 根据数据值删除
返回: None
注意: 如果要删除的数据不存在, 会报错

3. 清空数据(一般不用)

列表.clear()

my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
​
# 1. 删除最后一个位置的数据
num = my_list.pop()
print('删除的数据为:', num)
print(my_list)  # [1, 3, 5, 7, 9, 2, 4, 6, 8]
​
# 2. 删除下标为 1 的数据 3
my_list.pop(1)
print(my_list)  # [1, 5, 7, 9, 2, 4, 6, 8]
​
# 3. 删除数据为 7 的数据
my_list.remove(7)  # 注意, 如果列表中有多个 7, 只能删除第一个, 如果数据不存在,会报错的
print(my_list)  # [1, 5, 9, 2, 4, 6, 8]
​
# my_list.remove(7)  # 会报错的
​
# 清空
my_list.clear()
print(my_list)  # []

列表的反转

字符串中 反转倒置: 字符串[::-1] ​ 列表中 反转和倒置:

1. 列表[::-1] # 使用切片的方法,会得到一个新列表, 原列表不会发生改变
2. 列表.reverse() # 直接修改原列表, 返回 None

my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
# 使用切片的方法反转, 会得到一个新列表
list1 = my_list[::-1]
print('my_list:', my_list)   # [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
print('list1  :', list1)     # [0, 8, 6, 4, 2, 9, 7, 5, 3, 1]
# 使用 reverse 方法, 直接修改原列表
my_list.reverse()
print('my_list:', my_list)   # [0, 8, 6, 4, 2, 9, 7, 5, 3, 1]

列表的复制

将列表中的数据复制一份,给到一个新的列表 使用场景: 有一个列表, 需要修改操作列表中的数据, 修改之后,
需要和原数据进行对比,即原数据不能改

1. 使用切片
   变量 = 列表[:]
   ​
2. 使用 copy 方法
   变量 = 列表.copy()

my_list = [1, 2, 3]
my_list1 = my_list[:]
print('my_list :', my_list)  # [1, 2, 3]
print('my_list1:', my_list1) # [1, 2, 3]
my_list1[1] = 22
print('my_list :', my_list)  # [1, 2, 3]
print('my_list1:', my_list1)  # [1, 22, 3]

my_list2 = my_list.copy()
print('my_list :', my_list)   # [1, 2, 3]
print('my_list2:', my_list2)  # [1, 2, 3]
my_list2[2] = 33
print('my_list :', my_list)   # [1, 2, 3]
print('my_list2:', my_list2)  # [1, 2, 33]

my_list3 = my_list  # 这是同一个列表,多了一个名字, 引用
print('my_list :', my_list)    # [1, 2, 3]
print('my_list3:', my_list3)    # [1, 2, 3]
my_list3[0] = 11
print('my_list :', my_list)     # [11, 2, 3]
print('my_list3:', my_list3)    # [11, 2, 3]

8.2.9 列表的排序

列表的排序, 一般来说都是对数字进行排序的
列表.sort() # 按照升序排序, 从小到大
列表.sort(reverse=True) 降序排序, 从大到小

my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
# 升序排序
my_list.sort()
print(my_list)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 降序排序
my_list.sort(reverse=True)
print(my_list)  # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

列表嵌套

列表嵌套, 列表中的内容还是列表
使用下标来确定获取的是什么类型的数据,然后确定可以继续进行什么操作

person_info = [["张三", "18", "功能测试"], ["李四", "20", "自动化测试"]]
​
print(len(person_info))  # 2
print(person_info[0])  # ['张三', '18', '功能测试']
​
print(person_info[0][0])  # '张三'
​
print(person_info[0][0][0])  # 张
​
# 将 18 改为 19
person_info[0][1] = '19'
print(person_info)  # [['张三', '19', '功能测试'], ['李四', '20', '自动化测试']]
​
# 给 李四 所在的列表添加一个性别 信息
person_info[1].append('男')
print(person_info)  # [['张三', '19', '功能测试'], ['李四', '20', '自动化测试', '男']]
​
# 将张三的年龄信息删除
# person_info[0].pop(1)
person_info[0].remove('19')
print(person_info)  # [['张三', '功能测试'], ['李四', '20', '自动化测试', '男']]

元组

元组: tuple, 元组的特点和列表非常相似 ​

1. 元组中可以存放任意类型的数据
2. 元组中可以存放任意多个数据 ​ 区别:
3. 元组中的数据内容不能改变, 列表中的可以改变的
4. 元组使用 (), 列表 使用 [] ​ 应用: 在函数的传参或者返回值中使用, 保证数据不会被修改

定义

1. 使用 类实例化的方式
   1.1 定义空元祖(不会使用的)
   变量= tuple()
2. 直接使用 () 方式
   变量 = (1, “小王”, 3.14, False)

常用方法

由于元组中的数据不能修改,所以只有查看的方法 ​

1. 在元组中也可以使用 下标和切片获取数据
2. 在元组中存在 index 方法, 查找下标, 如果不存在,会报错
3. 在元组中存在 count 方法, 统计数据出现的次数
4. 在元组中可以使用 in 操作, 判断数据是否存在
5. len() 统计个数 以上方法的使用 和列表中一样的

# 1, 类实例化的方式
# 1.1 定义空元祖(不会使用的)
my_tuple1 = tuple()
print(type(my_tuple1), my_tuple1)  # <class 'tuple'> ()
# 1.2 类型转换
# 可以将列表转换为元组, 只需要将 [], 变为 (), 同时 可以将元组转换列表 , 将() 变为 []
my_tuple2 = tuple([1, 2, 3])
print(my_tuple2)  # (1, 2, 3)
# 转换字符串, 和列表中一样,只是将列表的[] 变为()
my_tuple3 = tuple('hello')
print(my_tuple3)  # ('h', 'e', 'l', 'l', 'o')
​
# 2. 直接使用 () 定义
my_tuple4 = (1, "小王", 3.14, False)
print(my_tuple4)
​
# 3. 特殊点, 定义只有一个数据的元组时, 数据后边必须有一个逗号
my_tuple5 = (1,)
print(my_tuple5)  # (1,)
​
print(my_tuple4[1])  # 小王

字典

1. 字典 dict, 字典中的数据是由键(key)值(value)对组成的(键表示数据的名字, 值就是具体的数据)
2. 在字典中一组键值对是一个数据, 多个键值对之间使用 逗号隔开 变量 = {key: value, key:value, …}
3. 一个字典中的键是唯一的,不能重复的, 值可以是任意数据
4. 字典中的键 一般都是 字符串,可以是数字, 不能是列表

定义

# 1. 使用 类实例化的方法
# 1.1 创建空字典
my_dict = dict()    
print(type(my_dict), my_dict)  # <class 'dict'> {}
​
# dict() 不能转列表和元组,字符串
​
# 2. 直接使用{} 定义
# 2.1 空字典
my_dict1 = {}
print(type(my_dict1), my_dict1)  # <class 'dict'> {}
​
# 2.2 非空字典, 小明('name') 18('age') 1.71('height') True(is_men)  抽烟 喝酒 烫头('like')
my_dict2 = {"name": "小明", "age": 18, "height": 1.71, "is_men": True, "like": ["抽烟", "喝酒", "烫头"]}
​
print(my_dict2)
print(len(my_dict2))  # 5**加粗样式**

增加和修改操作

语法: 字典[键] = 数据值

1. 如果键已经存在,就是修改数据值
2. 如果键不存在,就是添加数据(即添加键值对)

# 定义字典  小明 18 爱好
​
my_dict = {"name": "小明", "age": 18, "like": ['抽烟', '喝酒', '烫头']}
​
print(my_dict)  # {'name': '小明', 'age': 18, 'like': ['抽烟', '喝酒', '烫头']}
# 1. 添加性别信息 sex
my_dict['sex'] = '男'
print(my_dict)  # {'name': '小明', 'age': 18, 'like': ['抽烟', '喝酒', '烫头'], 'sex': '男'}
​
# 2. 修改年龄为 19
my_dict['age'] = 19
print(my_dict)  # {'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头'], 'sex': '男'}
​
# 3. 添加一个爱好, 学习--> 本质是向列表中添加一个数据
my_dict['like'].append('学习')
print(my_dict)  # {'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习'], 'sex': '男'}

删除

1. 删除指定键值对

del 字典[键]
or
字典.pop(键) # 键必须书写

2. 清空

字典.clear()

my_dict = {'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习'], 'sex': '男'}
​
# 删除  sex 键值对
del my_dict['sex']
print(my_dict)  # {'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习']}
​
# 字典.pop('键')
my_dict.pop('age')
print(my_dict)  # {'name': '小明', 'like': ['抽烟', '喝酒', '烫头', '学习']}
​
# 删除抽烟的爱好 ---> 本质操作是在列表中删除 数据值
# my_dict['like'].pop(0)
my_dict['like'].remove('抽烟')
# 或者
del my_dict["like"][0]
print(my_dict)  # {'name': '小明', 'like': ['喝酒', '烫头', '学习']}
​
​
# 清空键值对
my_dict.clear()
print(my_dict)  # {}
​

集合

集合（set）是一个无序的不重复元素序列。
集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。
可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典

语法：
parame = {value01,value02,…}
或者
set(value)

set1 = {1, 2, 3, 4}     # 直接使用大括号创建集合
set2 = set([4, 5, 6, 7]) # 使用 set() 函数从列表创建集合
set=set()            # 创建空集合

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False

>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

添加元素

语法格式如下：

s.add( x )

#将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> thisset.add("Google")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：

s.update( x )
x 可以有多个，用逗号分开

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}

移除元素

语法格式如下：

s.remove( x )

将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'

此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：

s.discard( x )

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}

清空集合
语法格式如下：

s.clear()**

计算集合元素个数

语法格式如下：

len(s)

计算集合 s 元素个数

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> len(thisset)
3

函数

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号 : 起始，并且缩进。 r
eturn [表达式]结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None

定义一个函数
def 函数名（参数列表）：
函数体

函数的返回值

函数的返回值,可以理解为是 函数整体执行的结果是什么
什么时候需要书写返回值: 函数中得到的数据在后续的代码中还要使用,这个时候就应该将这个数据作为返回值返回,以供后续使用

在函数中想要将一个数据作为返回值 返回, 需要使用 return 关键字(只能在函数中使用)
作用:

1. 将数据值作为返回值返回
2. 函数代码执行遇到 return, 会结束函数的执行

def 函数名():
    return  # return 后边没有数据, 返回值 None
​
​
def 函数名():
    return xx   # 返回值是 xx

返回值- 函数返回多个数据值

函数中想要返回一个数据值, 使用 return 关键字
将 多个数据值组成容器进行返回, 一般是元组(组包)

def calc(a, b):
    num = a + b
    num1 = a - b
    return num, num1
# 写法一
result = calc(10, 5)
print(result)  # (15, 5)
print(result[0], result[1])  # 15 5
# 写法二
x, y = calc(20, 10)
print(x, y)    # 15 5

匿名函数

匿名函数: 就是使用 lambda 关键字定义的函数
一般称使用def 关键字定义的函数为, 标准函数 ​
匿名函数只能书写一行代码
匿名函数的返回值不需要 return, 一行代码(表达式) 的结果就是返回值 ​
使用场景: 作为函数的参数,这个函数比较简单,值使用一次,没有必要使用 def 定义

lambda 参数: 一行代码   # 这一行代码,称为是表达式
# 匿名函数一般不需要我们主动的调用, 一般作为函数的参数使用的
# 1. 定义一个匿名函数可以求两个数的乘积 (参数需要两个, )
func1 = lambda a, b: a * b
​
# 2. 定义一个匿名函数, 参数为字典,返回字典中键为 age 的值
# 参数只是一个占位的作用,定义的时候没有具体的数据值, 形参的值是在调用的时候进行传递,此时,形参才有数据值形参的类型就是由实参来决定的, 在函数定义的时候,参数只是一个符号,写什么都可以, 想让其是字典类型,只需要保证
# 实参是字典即可
func2 = lambda x: x.get('age')
func3 = lambda x: x['age']
​
​
​
print(func1(1, 2))
print(func1(3, 2))
my_dict = {'name': '张三', 'age': 18}
print(func2(my_dict))
print(func3(my_dict))

面向对象

1.面向过程
关注的是 具体步骤的实现, 所有的功能都自己书写
亲力亲为
定义一个个函数, 最终按照顺序调用函数

2.面向对象
关注的是结果, 谁(对象) 能帮我做这件事
偷懒
找一个对象(), 让对象去做

以上两种都属于写代码的套路(方法) ,最终目的都是为了将代码书写出来,只不过过程和思考方法不太一样.

魔法方法

python 中有一类方法, 以两个下划线开头,两个下划线结尾,并且在满足某个条件的情况下, 会自动调用, 这类方法称为 魔法方法 ​
学习:

1. 什么情况下自动调用
2. 有什么用, 用在哪

__ init __方法

1. 什么情况下自动调用

   创建对象之后会自动调用

2. 有什么用, 用在哪

   1. 给对象添加属性的, (初始化方法, 构造方法) 2. 某些代码, 在每次创建对象之后, 都要执行,就可以将这行代码写在 init 方法

3. 书写的注意事项

   1. 不要写错了 2. 如果 init 方法中,存在出了 self 之外的参数, 在创建对象的时候必须传参

class Cat:
    # 定义添加属性的方法
    def __init__(self, name, age):  # 这个方法是创建对象之后调用
        self.name = name  # 给对象添加 name 属性
        self.age = age   # 给对象添加 age 属性
        print("创建对象 ,会输出")

    # 输出属性信息
    def show_info(self):
        print(f'小猫的名字是: {self.name}, 年龄是: {self.age}')

# 创建对象,不要在自己类缩进中创建
# Cat()  # 创建对象 ,会输出
blue_cat = Cat('蓝猫', 2)   # 创建对象 ,会调用__init——__方法
# blue_cat.show_info()

# 创建黑猫
black_cat = Cat('黑猫', 3)   # 创建对象 ,会调用__init——__方法
black_cat.show_info()   # 小猫的
名字是: 黑猫, 年龄是: 3

_ _ str _ _ 方法 *

1. 什么情况下自动调用

   使用 print(对象) 打印对象的时候 会自动调用

2. 有什么用, 用在哪

   在这个方法中一般书写对象的 属性信息的, 即打印对象的时候想要查看什么信息,在这个方法中进行定义的
   如果类中没有定义 str 方法, print(对象) ,默认输出对象的引用地址

3. 书写的注意事项

   这个方法必须返回 一个字符串

class Cat:
    # 定义添加属性的方法
    def __init__(self, n, age):  # 这个方法是创建对象之后调用
        self.name = n  # 给对象添加 name 属性
        self.age = age   # 给对象添加 age 属性

    def __str__(self):
        # 方法必须返回一个字符串, 只要是字符串就行,
        return f'小猫的名字是: {self.name}, 年龄是: {self.age}'

# 创建对象,不要在自己类缩进中创建
# Cat()  # 创建对象 ,会输出
blue_cat = Cat('蓝猫', 2)
print(blue_cat)   # 小猫的名字是: 蓝猫, 年龄是: 2