软件测试--python基本数据类型和变量

Python 简介

Python 是一种解释型、面向对象、动态数据类型的高级程序设计语言。

• Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于Java、PHP和Perl语言。
  【C语言是编译语言，而Python和Java是解释型语言。编译语言在运行的时候通过预处理、编译器编译等转化成机器语言（一种低级语言），生成可执行文件，运行的效率高，速度快；而解释型语言则是在程序每次运行的时候一句一句把程序运行，所以效率相比较偏低运行慢。相比较而言，C语言更加适合去写追求运行效率的和底层运行有关的东西】
• Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。【C是一种面向过程的语言，python和java面向对象】
• Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。
• Python是动态语言、强类型语言

静态编译语言

• 实现声明变量类型，类型不能再改变
• 编译时检查

动态编译语言

• 不用事先声明类型，随时可以赋值为其他类型
• 编程时不知道是什么类型，很难推断

强类型语言

• 不同类型之间操作，必须先强制类型转换为同一类型。print(‘a’+1)

弱类型语言

• 不同类型间可以操作，自动隐式转换，JavaScript中console.log(1+‘a’)

基础语法

注释

以# 开头的就是注释.不会被执⾏
快捷键 Ctrl /
可以选中多⾏, 使⽤快捷键

变量

变量是啥

变量其实是通过定义的一个标记用来调用内存中的值，这个标记的名称就是变量名。

它可以是数字、字符串、对象或其他数据类型的存储空间。通过给变量赋值，可以将某个值存储在变量中，然后在代码中可以通过变量名来访问这个值。
在Python中，变量是动态类型的，这意味着变量的数据类型可以根据赋予给它的值自动确定，并且可以在程序运行时更改变量的值和类型。

只有符合下面条件的变量名才是有效的变量名，否则就会报错。

• 变量名只能为数字, 字母, 下划线组成
• 不能使用数字开头
• 不能使用Python内置关键字
• 严格区分大小写
• 不建议使用中文

Python 的关键字有
[‘and’，‘as’，‘assert’，‘break’，‘class’，‘continue’，‘def’，‘del’，‘elif’，‘else’，‘except’，‘exec’,‘finally’，‘for’,from’，‘global’，‘if’,‘import’，‘in’，‘is’,‘lambda’,‘not’,or’, ‘pass’,‘print’,‘raise’, ‘return’,‘try’,‘while’,with’,‘yield’]

标识符-命名习惯

驼峰命名

• 大驼峰：每个单词首字母大写, 例如: MyName
• 小驼峰：第二个单词开始首字母大写, 例如: myName

下划线命名

• 每个单词之间使用下划线连接, 例如: my_name

好的命名习惯要做到 见名知意

数据类型

想要获取变量的数据类型, 可以使⽤ type(变量) 函数

数字型

数字还能分不同的类型?

• 整数/int
• 浮点数/float
• 布尔值/bool

# int 整型 整数
age = 18
print(type(age)) # <class 'int'>
# float 浮点型 ⼩数
height = 1.71
print(type(height)) # <class 'float'>
# bool 类型,True(真) 和 False(假), 都是关键字
# is_men = True
is_men = False
print(type(is_men)) # <class 'bool'>

# 字符串 str, 使⽤ 引号引起来的就是字符串
name = 'tom'
print(type(name))
num = '20'
print(type(num)) # <class 'str'>

数据类型转换

Python 中数字的类型是可以相互转化的
1.通过类型函数来转化

• int() 将其他类型转换为 int 类型
• float 类型 可以转换为 int 类型
• 整数类型的字符串 才可以转换为 int 类型 3, 18
• float() 将其他类型 转换为 float 类型
• int 类型 可以转换为 float 类型
• 数字类型的字符串 都可以转换为 float 类型
• str() 将其他任意类型 转换为 字符串类型 加引号

age = input('请输⼊你的年龄:')
print(type(age), age) # <class 'str'> 18
# 需求,将字符串的 18 转换为 int 类型的 18
new_age = int(age) # 数据类型转换不会改变 age 的类型,
⽣成⼀个新的数据保存到 new_age
print(type(age), age) # <class 'str'> 18
print(type(new_age), new_age) # <class 'int'> 18

2.通过运算来进行转化示例如下:

print(type(3/2.0),3/2.0)<class 'float'> 1.5

其他内置函数：
bool() :将其他类型的数据转换成布尔值。
abs() :返回一个数的绝对值。
round() :对一个数进行四舍五入。

a=bool(1)
print(a)#输出: True
print(type(a))#输出:<class bool'>

b=abs(-5)
print(b)#输出: 5

c=round(3.147)
print(c)#输出: 3

输入

获取键盘的输⼊. 使⽤函数 input()
变量 = input('给使⽤者的提示信息,即告诉别⼈输⼊什么内
容')
1, 代码从上到下执⾏, 当代码执⾏遇到 input 的时候,会暂停
代码的执⾏,等待⽤户的输⼊
2, 在输⼊的过程中,如果遇到回⻋键,表示本次输⼊结束
3, 使⽤ input 获取的内容, 都是字符串类型,即 str

# 需求, 从键盘录⼊你的姓名
name = input('请输⼊你的姓名:')
print(type(name), name) # 打印类型和变量的值

输出

Python 中想要进⾏输出,使⽤的函数就是 print

转义字符

将两个字符进⾏转义表示⼀个特殊的字符
\n ---> 换⾏,回⻋
\t ---> 制表符, tab键
print( end='\n') print 函数中默认有⼀个 end='\n', 所
以,每个 print 结束之后, 都会输出⼀个 换⾏
print('hello world', end=' ')
print('hello\nworld')
print('hello python')
print('hello\tpython')

运算符

• 算术运算符

优先级: () > ** > * / // % > + -
% 的使⽤场景: 判断⼀个数字是不是偶数, 能被 2 整除的数是 偶数
数字除以 2 余数是 0

• 比较运算符

> < >= <= 只能是相同类型之间进⾏⽐较 (数字和字符串之间不能使⽤)

• 赋值运算符和复合赋值运算符
  
  
• 逻辑运算符

and or not 是关键字

• and 逻辑与 并且, 连接两个条件, 只有都为 True, 结果才 为 True, ⼀假为假
• or 逻辑或 或者, 连接两个条件, 只要⼀个条件 为 True, 结果就为 True, ⼀真为真
• not 逻辑⾮ 取反, 本来是 True, 加上 not 变为False
  

非数字型

序列：我是啥？

在介绍列表和元组前，先引入两个概念:

1. 数据结构
   即通过某种方式组织在一起的元素的集合
2. 序列
   最基本的数据结构，序列中每个元素会被分配一个序号，即元素的位置，也称为索引从左往右，从0开始。

Python中有6种内置序列，字符串，列表，元组，buffer对象，xrange对象Unicode字符串，我们会通过列表来展示序列的共有特性。
也就是说这些特性，不管是 字符串，列表，还是元组 ，buffer对象都具有。

我们这边用列表来展示序列的共有特性，先简单介绍一下列表的形式，即用[]来表示，中间的元素用，隔开。如 [1,2,3]

1. 序列中可以包换不同类型的元素

#既有字符串，又有数字
a =['zhang',23]

2. 序列种可以包含其他序列

a =['zhang',23]
data = [a,33]
print (data)----->[['zhang'，23]，33]

序列:我有啥(操作)?

1.下标（索引）

1, 下标(索引), 是数据在容器(字符串, 列表, 元组)中的位置, 编号
2, 一般来说,使用的是正数下标, 从 0 开始
3, 作用: 可以通过下标来获取具体位置的数据. 使用的语法为
容器[下标]
4, Python 中是支持负数下标, -1 表示最后一个位置的数据

需要注意的是，当使用负数作为索引时，Python 会从右边开始计数，最后一个元素编号是 -1，另外，字符串字面值就可以直接使用索引。看下面示例：

2.切片

1, 使用切片操作, 可以一次性获取容器中的多个数据(多个数据之间存在一定的规律,数据的下标是 等差数列(相邻的两
个数字之间的差值是一样的)) 2, 语法 容器[start: end: step]
2.1 start 表示开始位置的下标
2.2 end 表示结束位置的下标,但是 end 所对应的下标位置的数据是不能取到的
2.3 step 步长,表示的意思就是相邻两个坐标的差值 start, start+step, start+step*2, …,end(取不到)

my_str = 'abcdefg'
# 需求1 : 打印字符串中 abc 字符 start 0, end 3, step 1
print(my_str[0:3:1]) # abc
# 1.1 如果步长是 1, 可以省略不写
print(my_str[0:3]) # abc
# 1.2 如果 start 开始位置的下标为 0, 可以不写,但是冒号不能少
print(my_str[:3]) # abc
# 需求 2: 打印字符串中的 efg , start 4, end 7, step 1
print(my_str[4: 7]) # efg
# 2.1 如果取到最后一个字符, end 可以不写,但是冒号不能少
print(my_str[4:]) # efg
# 需求 3: 打印字符串中的 aceg , start 0, end 7(最后), 步长 2
print(my_str[::2]) # aceg
# 练习: cf
print(my_str[2:6:3])
# 面试高频题：特殊情况, 步长为 -1, 反转(逆序) 字符串
print(my_str[::-1]) # gfedcba

3.序列相加 需要注意的是，两种相同类型的序列才可以相加。否则会报错

>>> [1,2,3] + [3,4,5]
[1，2，3，3，4，5]
>>>'hello' + 'zhang
hellozhang
>>> [1,2,3] +'hello'
Traceback (most recent call last):
  File "<stdin>"，line 1,in <module>
TypeError: can only concatenate list (not "str") to list

4.序列相乘

>>>python'*3
pythonpythonpython
>>> [1,2,3] *2
[1， 2, 3，1，2，3]

5.成员资格 判断某个元素是否在序列中

>>> permission =yw
>>> 'y' in permission
True
>>> x' in permission
False
>>> user =['zhang',wang']
>>> zhang' in user
True
>>> 'li' in user
False

6.长度，最大值，最小值

>>> nums =[63,81,11]
>>> len(nums)
3
>>> max(nums)
81
>>> min(nums)
11

以上就是序列中(部分常见的)的共有特性，也就是说列表，元组，字符串都具有上面的特性。

序列的小弟之一-- 列表 list

列表(list)是序列的一种，是由 [] 包围的，以“，”隔开的素的集合,可以随时添加或删除其中的元素

• 如何生成列表

# 方式1, 使用类实例化的方式
# 1.1 定义空列表 变量 = list()
list1 = list()
print(type(list1), list1) # <class 'list'> []
# 1.2 定义非空列表 , 也称为 类型转换 list(可迭代类型) 可迭代类型,能够使用 for 循环 就是 可迭代类型(比
如 容器)
# 将容器中的 每个数据 都作为列表中一个数据进行保存
list2 = list('abcd')
print(list2) # ['a', 'b', 'c', 'd']
# 方式2, 直接使用 [] 进行定义(使用较多)
# 2.1 定义空列表
list3 = []
print(list3)
# 2.2 定义非空列表
list4 = [1, 3.14, 'hello', False]
print(list4)

• 列表有哪些操作(增删改查)

>>> a = [1,2,3] #将列表[1,2,3] 赋值给变量a
#修改列表中索引1的值
>>>a[1] =5
>>>a
[1, 5,3]
#删除元素
>>>del a[2]
>>>a
[1,5]
#分片赋值
>>> name = list('perl')
>>> name
['p','e','r','l']
>>> name[2:] = list(ar')
>>> name
['p','e','a','r']
#分片赋值可以代替原序列中长度不同的值
>>> name = list('Perl')
>>> name
['p','e','r','l']
>>> name[1:] = list('ython')
>>> name
['p','y','t','h','o', 'n'],
#插入
>>> nums = [1,5]
>>> nums[1:1] =[2,3,4]
>>>nums
[1， 2，3，4，5]
#删除
>>>nums[1:4] = []
>>>nums
[1，5]

1. 列表查询

• index() 方法

index() 这个方法的作用和 字符串中的 find() 的作用是一样 列表中是没有 find() 方法的, 只有 index() 方法
字符串中 同时存在 find() 和 index() 方法
index()
1, 找到 返回下标
2, 没有找到, 直接报错

• count() 方法

列表.count(数据) # 统计 指定数据在列表中出现的次数，不存在的返回0

list1 = ['hello', 2, 3, 2, 3, 4]
# 查找 2 出现的下标
num = list1.index(2)
print(num) # 1
# 统计数据 2 出现的次数
num1 = list1.count(2)
print(num1) # 2
# 统计数据 20 出现的次数
num2 = list1.count(20)
print(num2) # 0

• in

查询指定元素是否在列表中

• not in

查询指定元素是否不在列表中

num_list = [1, 2, 3, 4, 5, 6, 7, 8, 5]
# in  判断数据元素是否在列表内  如果在  True  如果不在False
# TypeError: argument of type 'int' is not iterable
# print(num_list in 5)
# 注意使用in或者not in  数据元素在左边,  列表或者其他数据序列在右侧
print(5 in num_list)  # True
print(9 in num_list)  # False
# not in  判断数据元素是否不在列表内  如果不在  True  如果在False
print(5 not in num_list)  # False
print(9 not in num_list)  # True

2.添加数据

• append() [重点]

列表.append(数据) # 向列表的尾部添加数据

#返回: None, 所以不用使用 变量 = 列表.append() 直接在原列表中添加数据, 不会生成新的列表,如果想要查看添加后的数据, 直接 print() 打印原列表

>>>lst = [2,'23']
>>>lst.append(3)
>>>lst
[2,'23'，3]

• extend()

可以在列表的未尾一次性追加另一个序列的多个值，也就是可以用新列表扩展原有列表与列表的连接作用不同，连接作用返回一个新的列表，extend()是修改了被扩展的列表

>>>a =[1,2,3]
>>>b= [4,5,6]
>>>a.extend(b)
>>>a
[1，2，3，4，5，6]

>>>a= [1,2,3] 
>>>b=[4,5,6]
>>>a+b
[1，2，3，4，5，6]
>>>a
[1，2，3]

• insert()

将对象插入到列表指定的索引位置–修改了原列表的值却返回None 值

>>>nums = [1,2,3, 4,5]
>>>a = nums.insert(3,'zhang')
>>> print(a)
None
>>> nums
[1，2，3，'zhang'，4，5]

3.**删除数据 **

• pop()

列表.pop(index) # 根据下标删除列表中的数据

• index 下标可以不写, 默认删除在最后一个
• 返回, 删除的数据
  

# 定义空列表
list1 = []

print(list1)
# 添加数据 张三
list1.append('张三')
print(list1)

# 添加李四
list1.append('李四')
print(list1)
list1.append('王五')
list1.append('赵六')
print(list1)

# 删除最后一个数据
list1.pop()
print(list1)
# 删除第二个数据
name = list1.pop(1)
print('删除的对象为:', name)
print(list1)
>>>运行结果：
[]
['张三']
['张三', '李四']
['张三', '李四', '王五', '赵六']
['张三', '李四', '王五']
删除的对象为: 李四
['张三', '王五']

• del
  先对列表中的元素进行查找（使用下标），找到后使用del删除

# del  将数据引用切断
list1 = [1, 2, 3, 4]
# del list1
# NameError: name 'list1' is not defined
# del不仅可以删除元素,也可以删除任何变量,非常强大,但是有些不安全
# print(list1)
# 那del 怎样删除元素呢?  通过索引获取当前元素,并删除
# del list1[9]
# IndexError: list assignment index out of range
# 使用下标查找数据时,下标索引不能不存在
del list1[2]
print(list1)  # [1, 2, 4]

• remove()

用于移除列表中的第一个匹配项，如果没有匹配报错，改变了列表返回 None，同 reverse(元素反向)

>>>x = ['to','be','or','not' ,'to','be']
>>>x.remove('be')
>>>x
['to', 'or' ,'not','to', 'be']
>>> x.remove('too')
Traceback (most recent call last):
 File "<pyshell#68>"，line 1，in <module>
   x.remove('too')
ValueError: list.remove(x): x not in list

• clear()

清空列表，和重新赋值为空有逻辑上的区别。

# clear  清空列表
# 就是讲列表置为[],但是与list1 = [] 有本质区别
list1.clear()
print(list1)  # []

4.修改数据

• 使用索引修改

想要修改列表中的数据, 直接是所有下标即可
列表[下标] = 新数据
查询列表索引值必须在列表中存在

my_list = [1, 2]
my_list[0] = 10
print(my_list)#[10, 2]
my_list[-1] = 200
print(my_list)#[10, 200]
# my_list[2]=20
# IndexError: list assignment index out of range
# 获取的元素位置,必须是存在的

• 列表的反转 reverse()

字符串 反转 字符串[::-1]
列表 反转

1. 列表[::-1] 得到一个新的列表, 原列表不会改动
2. 列表.reverse() 直接修改原列表的数据

my_list = ['a', 'b', 'c', 'd', 'e']
# 1. 切片
my_list1 = my_list[::-1]
print('my_list :', my_list) # my_list : ['a', 'b', 'c', 'd', 'e']
print('my_list1:', my_list1)# my_list1: ['e', 'd', 'c', 'b', 'a']
# 2. reverse
my_list.reverse()
print('my_list :', my_list)# my_list : ['e', 'd', 'c', 'b', 'a']

• 列表的排序

#前提: 列表中的数据要一样
列表.sort() # 升序, 从小到大, 直接在原列表中进行排序
列表.sort(reverse=True) # 降序, 从大到下, 直接在原列表中进行排序

my_list = [1, 4, 7, 2, 5, 8, 3, 6, 9]
# 排序 升序
my_list.sort()
print(my_list)#[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]

5.列表的嵌套

列表的嵌套 就是指 列表中数据都是列表.

student_list = [["张三", "18", "功能测试"], ["李四", "20", "自动化测试"], ["王五", "21", "自动化测试"]]

print(student_list[0][0])# 张三

print(student_list[1][0])# 李四
# 张三 的信息添加一个 性别 男 ---> 向张三所在的列表 添加数据
student_list[0].append('男')
print(student_list)# [['张三', '18', '功能测试', '男'], ['李四', '20', '自动化测试'], ['王五', '21', '自动化测试']]
# 删除 性别
student_list[0].pop()
print(student_list)# [['张三', '18', '功能测试'], ['李四', '20', '自动化测试'], ['王五', '21', '自动化测试']]
# 打印 所有人员的年龄

for info in student_list: # info 是 列表
  print(info[1])
  # 18
  # 20
  # 21

序列的小弟之二-- 元组 tuple

1, 元组 tuple, 使用的 ()
2, 元组和列表非常相似, 都可以存储多个数据, 都可以存储任意类型的数据
3, 区别就是元组中的数据不能修改,列表中可以修改
4, 因为元组中的数据不能修改,所以只能 查询方法, 如 index, count ,支持下标和切片
5, 元组, 主要用于传参和返回值

• 如何生成元组

# 1. 类实例化方式
# 1.1 定义空元组(不用)
tuple1 = tuple()
print(type(tuple1), tuple1) # <class 'tuple'> ()
# 1.2 类型转换 , 将列表(其他可迭代类型)转换为元组
tuple2 = tuple([1, 2, 3])
print(tuple2)
# 2. 直接使用 () 定义
# 2.1 定义空元组
tuple3 = ()
# 2.2 非空元组
tuple4 = (1, 2, 'hello', 3.14, True)
print(tuple4)
print(tuple4[2]) # hello
# 2.3 定义只有一个数据的元组, 数据后必须有一个逗号
tuple5 = (10,)
print(tuple5)

• 元组常用方法

1. count（）方法：用于统计指定元素在元组中出现的次数。
2. index()方法:用于查找指定元素在元组中的索引位置。如果指定的元素不存在于元组中，则会引发ValueError。
3. len()函数:用于获取元组的长度。
4. sorted()函数:用于对元组进行排序，并返回一个新的列表。需要注意的是，sorted()函数返回的是一个新的列表，而原始的元组不会被修改。

序列的小弟之三-- 字符串 str

字符串是一个有序的，不可修改的，元素以引号包围的序列。-- 注意，还是一个序列

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

# 1. 使用单引号
str1 = 'hello'
# 2. 使用双引号定义
str2 = "hello"
# 3. 使用 三引号 定义
str3 = """hello"""
str4 = '''hello'''
print(type(str1), type(str2), type(str3), type(str4))
# 4. 定义字符串 I'm 小明, 字符串本身包含引号
# 4.1 如果字符串本身包含单引号,定义的时候不能使用 单引号,
# 4.2 如果字符串本身包含双引号,定义的时候不能使用 双引号,
str5 = "I'm 小明"
print(str5) # I'm 小明
# 5. 转义字符 \n \t \' \"
str6 = 'I\'m 小明'
print(str6) # I'm 小明
# 6. I\'m 小明 \\ --> \
str7 = 'I\\\'m 小明'
print(str7) # I\'m 小明
# 7. 原生字符串 在字符串的前边 加上 r"", 字符串中的 \ 就不会进行转义
str8 = r'I\'m 小明'
print(str8) # I\'m 小明
str7 = r'I\\\'m 小明'
print(str7) # I\\\'m 小明

• 字符串的格式化

按照⼀定的格式,在字符串中使⽤ 变量, 将变量的值进⾏输出

# 字符串格式化适用字符串格式化操作符即百分号% 来实现
format = 'hello ,%s,%s enough for you'
values = ('haha','zhang' )
print(format % values)
# hello ,haha,zhang enough for you

• 字符串.format()

1, 可以在任意的 Python 版本中使⽤
2, 字符串中需要使⽤变量的地⽅,使⽤ {} 进⾏占位
3, 在 format 的括号中按照占位的顺序,将变量写上去

• F-string

1, python 3.6 版本开始可以使⽤,即⼤于等于 3.6 可以使⽤
2, 在字符串前边加上 f’’ 或者 F’’
3,字符串中需要使⽤变量的地⽅,使⽤ {} 进⾏占位
4, 将变量直接写在 占位的⼤括号中

name = '⼩明'
age = 18
sex = '男'
# 我的名字是 xx, 年龄 xx 岁, 性别为 xx.
print('我的名字是 ' + name + ', 年龄 ' + str(age) + '
岁, 性别为 ' + sex + '.')
print('我的名字是 {}, 年龄 {} 岁, 性别为
{}.'.format(name, age, sex))
print(f'我的名字是 {name}, 年龄 {age} 岁, 性别为
{sex}.')

• 字符串的连接 join

字符串.join(容器) # 容器一般是列表 , 将字符串插入到列表相邻的两个数据之间,组成新的字符串
注意点: 列表中的数据 必须都是字符串才可以

list1 = ['hello', 'Python', 'and', 'itcast', 'and', 'itheima']
# 将 列表中数据使用 空格 组成新的字符串
str1 = ' '.join(list1)
print(str1) # hello Python and itcast and itheima
# 使用 逗号 连接
str2 = ','.join(list1)
print(str2) # hello,Python,and,itcast,and,itheima
# 使用 _*_ 连接
str3 = '_*_'.join(list1)
print(str3) # hello_*_Python_*_and_*_itcast_*_and_*_itheima

• 字符串拆分
  

>>>a = 'i am a badyboy
>>> a.split()
['i' ,'am','a','badyboy ']
>>> a.split('',2)
['i', ' am' ,'a badyboy']

>>> a.split('a')
['i','m','b',' dyboy' ]
>>> a.split('a',2)
['i','m'，' badyboy']

>>>a='''i'm a boy
i'm 20
i am in shanghai'''
>>> a.splitlines()
["i'm 20",'i am in shanghai']

• 字符串的替换 replace()

字符串.replace(old, new, count) # 将字符串中的 old 字符串 替换为 new 字符串

• old 原字符串,被替换的字符串
• new 新字符串,要替换为的字符串
• count 一般不写,表示全部替换, 可以指定替换的次数
• 返回: 会返回一个替换后的完整的字符串
• 注意: 原字符串不会改变的

my_str = 'good good study'
# 需求, 将 good 变为 GOOD
my_str1 = my_str.replace('good', 'GOOD')
print('my_str :', my_str)
print('my_str1:', my_str1)
# 将第一个 good 替换为 Good
my_str2 = my_str.replace('good', 'Good', 1)
print('my_str2:', my_str2)
# 将第二个 good 替换为 Good
# 先整体替换为 Good, 再将替换后的 第一个Good 替换为 good
my_str3 = my_str.replace('good', 'Good').replace('Good', 'good', 1)
print('my_str3:', my_str3)

• 字符串查找方法
  
  
• 字符串修饰
  
  
• 字符串的大小写转换
  
  
• 字符串的判定
  
  

字典 dict

字典(dict)是Python的一种内置的数据结构。在其他语言中也称为map,使用键-值(key-value) 存储，可以通过查找某个特定的词语 (键 key)，从而找到他的定义(值 value)

• 创建字典的两种方法

# 1, 类实例化的方式
my_dict1 = dict()
print(type(my_dict1), my_dict1) # <class 'dict'> {}
# 2, 直接使用 {} 定义
# 2.1 定义空字典
my_dict2 = {}
print(my_dict2)
# 2.2 定义非空字典, 姓名, 年龄, 身高, 性别
my_dict = {"name": "小明", "age": 18, "height": 1.78, "isMen": True}
print(my_dict)

• key 有啥特性

1.如果同一个键被赋值两次，后一个值会被记住

2.键是不可变得，所以数字，字符串或元组可以作为键，而用列表就不行，如下实例:

• dict增删改查如何实现
  

• dict —> str
  在每个转换说明符中的%后加上键(用括号)，后面再跟上其他说明元素
  

• 字典有哪些常用方法
  1.clear – 清除字典中的所有项。无返回值，或者可以理解为 返回None
  
  2.copy–返回一个具有相同键-值的新字典
  当简单的值替换的时候，原始字典和复制过来的字典之间互不影响，但是当添加，删除等修改操作的时候，两者之间会相互影响。 —可以理解为浅复制
  

copy对于一个复杂对象的子对象并不会完全复制，什么是复杂对象的子对象呢?就比如序列里的嵌套序列，字典里的嵌套序列等都是复杂对象的子对象。对于子对象，python会把它当作一个公共镜像存储起来，所有对他的复制都被当成一个引用，所以说当其中一个引用将镜像改变了之后另一个引用使用镜像的时候镜像已经被改变了。

deepcopy 可以避免上面出现的情况，我们可以理解为完全复制然后变成一个新的对象，复制的对象和被复制的对象没有任何关系，彼此之间无论怎么改变都相互不影响。

3.fromkeys–使用给定的键建立新的字典，每个键默认对应的值为 None

4.get–更宽松的访问字典项的方法，如果键不存在，返回None

5.items-- 将字典所有项以列表方式返回列表中每一项都会表示为 (键值)对的形式，但没有什么次序

6.keys – 将字典中的键以列表形式返回

7.pop–用来获得对应的键的值，并删除这对键值对

8.popitem --弹出随机的项，并删除

9.setdefault–类似于get方法，能够获得给定键相关联的值，还能在字典中不含有给定键的情况下设定相应的键值

10.update --利用一个字典更新另外一个字典，被更新的字典 会加到 原字典中键相同的话会被覆盖

集合set–无序的不重复的序列

集合(set)是一个无序的不重复元素序列，集合中的元素不能重复,且集合是无序的，不能通过索引和分片进行操作。（唯一性、无序性、可变性）

• 如何创建set
  1.set()创建一个集合，需要提供一个序列 (可迭代的对象)作为输入参数:
  
  2.{}
  
  但注意利用{}来创建集合不能创建空集合，因为{}是用来创造一个空的字典
• 集合函数跟方法

1. len()函数:获取集合中元素的数量。
2. add() 方法:向集合中添加一个元素。
3. remove()方法: 删除指定元素，如果元素不存在则抛出错误。
4. pop() 方法: 随机删除并返回集合中的一个元素。
5. clear() 方法: 清空集合中的所有元素。

#len()函数获取集合中元素的数量
fruits = ('apple'，'orange"，'bananaprint
(len(fruits)) # 输出: 3
#add()方法:向集合中添加一个元素
fruits.add('grape")
print(fruits) #输出:[ apple'， orange'，'banana'，'grape"]
# remove()方法: 删除指定元素，如果元素不存在则抛出错误
fruits.remove('orange)
print(fruits) #输出:[ apple'，'banana']
# pop()方法:随机删除并返回集合中的一个元素
removed_fruit = fruits.pop()
print(removed_fruit) # 输出随机删除的一个元囊
print(fruits) #输出:集合中剩下的元素
# clear()方法:清空集合中的所有元素
fruits.clear()
print(fruits) #输出: set()，表示集合为空集