1、字符串【str】
1、概念：
用来记录文本信息
2、表示方法：
‘’ “ ” ‘’’ ‘’’ “”” ”””
‘’：用的最多，单引号用可以套用双引号
print(‘我说：“你好”’)
“”：双引号中是可以套用单引号
print(“This’s a book”)
“”” “”” ‘’’ ’’’：多行注释、文档字符串【函数或实例方法中做功能的解释说明】，默认的换行功能
\ 换行符
3、特殊字符：
Python解释器在解释其内容是会将特殊字符进行转义：
\n 换行符
\t 制表符【默认是8个空格】
\r 将光标返回首行
\’ ’
\
源字符【Raw】:
作用：将特殊字符的转义功能失效
格式：r’’ r”” r””” ””” r’’’ ’’’
示例：
print(r’’‘C:\nate\teacher\read’’’) # C:\nate\teacher\read
4、字符串的拼接与分割
1、分割
str.split([sep]) # 按照sep【分割的依据】分割字符串，当sep参数不设置是表示按照空格分割，不限制空格的数量
返回值：列表【list】
示例：
s = ‘s+t+r+i+n+g’ s.split(sep=’+’) # [‘s’, ‘t’, ‘r’, ‘i’, ‘n’, ‘g’]
>>> s1 = ‘s d d g i’
>>> s1.split(sep=’ ') # [‘s’, ‘d’, ‘’, ‘d’, ‘’, ‘g’, ‘i’]
>>> s1.split() # [‘s’, ‘d’, ‘d’, ‘g’, ‘i’]
2、拼接：
1、+
>>> ‘hello’ + ‘world’ # ‘helloworld’
2、靠近
>>> ‘hello’‘world’ # ‘helloworld’
3、join函数
格式：‘连接符’.join(字符串)
>>> s = ‘abc’
>>> ‘+’.join(s) # ‘a+b+c’
5、字符串的运算
1、算术运算符
+ *
+ ： 字符串的拼接，不会改变原字符串
* : 将字符串重复一定的次数，不会改变原字符串
格式：‘str’* num【次数(int)】
示例：
>>> ‘abc’ * 4 # ‘abcabcabcabc’
>>> ‘abcabc’ + ‘a’ # ‘abcabca’
2、复合运算符：
+= *=
+= ：字符串的拼接，会改变原字符串
*= ：将字符串重复一定的次数，会改变原字符串
示例：
>>> s # ‘abc’
>>> s += ‘abc’
>>> s # ‘abcabc’
>>> s *= 3
>>> s # ‘abcabcabcabcabcabc’
3、比较运算符：
符号：< <= > >= == !=
比较依据：按照对应位置上的字符的Unicode值的大小进行比较
内置函数：
ord(sub) 查看当前字符的Unicode值
chr(code) 根据Unicode值返回对应的字符
练习：
1、打印‘abc…z’
2、打印‘AaBb….Zz’
6、in not in运算符
作用：用于判断某个对象是否在序列中
格式：obj in/not in 序列
序列：str/list/tuple/dict/set
返回值：布尔类型【bool】
说明：not in与in正好相反
>>> s = 'abscdd'
>>> 'a' in s # True
1
2
7、字符串的索引
格式：str[index]
说明：index【索引值】，字符串的第一个字符的索引值为0，第二个索引值为1，……最后的一个字符的索引值：len(str)-1 -索引值为正
字符串的第一个字符的索引值为：-1，第二个的索引值为：-2, …最后一个字符的索引值为：-len(str) -> 索引值为负
List item
内置函数：
len(序列) 获取当前序列的长度
实例：
str P Y T H O N
正向索引值 0 1 2 3 4 5
反向索引值 -6 -5 -4 -3 -2 -1
原则：‘就近原则’
缺点：只能通过索引值取出对应字符串中的一个字符
7、字符串的切片
作用：通过切片的方式获取字符串中连续或一定间隔的字符
格式：str[[strart_index]:[stop_index][:step]]
参数：
start_index: 表示切片的起始位置，可以不设置，则：
正向切片：表示字符串的开头位置
反向切片：表示字符串的末尾位置
stop_index: 表示切片的终止位置，对应的值取不到，可以不设置，则：
正向切片：表示字符串的末尾位置
反向切片：表示字符串的起始位置
step: 表示切片的偏移量或间隔【步长】，可以不设置，默认为为1，可正可负
正：正向切片
负：反向切片
练习：
s = ‘abcdefg’
s[3] # ‘d’
s[:-5] # ’ab’
s[-3:2] # ‘’
s[-4:7:2] # ‘df’
s[-3:6:-3] # ’’
9、字符串的遍历
格式：for 变量 in 非空的字符串：
语句块
10、字符串常用的方法
str –》 S
内置函数：dir(obj) 查看当前对象拥有的方法
方法 描述
S. isalpha() 判断当前字符串是否全是字母
S.isdigit() 判断当前字符串是否全是数字
S.isspace() 判断当前字符串是否为空格字符串
S.upper() 将当前字符串中的字母全部转化为大写
S.lower() 将当前字符串中的字母全部转化为小写
S.strip() 去除字符串左右的空白
S.lstrip() 去除字符串左侧的空白
S.rstrip() 去除字符串右侧的空白
S.center(width, [fillchar]) 按照一定的宽度将字符串居中，如果宽度大于字符串的长度时，可以设置fill的值用于填充空白
S.count(sub, [start, end]) 按照指定范围查找当前字符出现的次数
S.find(sub, [start, end]) 返回对应区间内字符的索引值【默认从左至右查找】，如果查找的字符不存在，则返回-1
S.index(sub, [start, end]) 返回对应区间内字符的索引值【默认从左至右查找】，如果查找的字符不存在，产生ValueError
S.replace(old, new, [count]) 从左至右将旧的字符替换为新的字符，如果不设置count值，默认全部替换，同时，替换的字符不存在，则返回原字符串
help(str.method) # 返回字符串方法的使用
练习：
1、用户输入的是数字，将结果进行5次方，并打印
2、用户输入的是字母，将其转化为大写，按照20个宽度居中，并打印
3、如果用户输入为空或为未输入，结束输入
4、如果用户输入的是浮点数，则将其保留两位小数并打印
11、格式化字符串
1、格式1：
格式：‘占位符’ % value
‘占位符1, 占位符2, …’ % (value1, value2, …)
说明：占位符要与值个数相同
占位符：
%d 十进制的整数
%f 十进制浮点数
%s 字符串
修饰符：
1、 左对齐
0 用于填充左侧空白【不能与0同时使用】
%-nd n 表示的是显示整型的宽度， - 左对齐【宽度小于整型的长度时，则宽度无效】
%-m.nf m 表示的浮点数显示的宽度，n表示的保留浮点数的位数
%ns n 表示的字符串显示的宽度
2、格式2：
格式：’{} {} …’.format(v1, v2, ….)
‘{编号2} {编号1} {编号…}’.format(v0, v1, v2, …)
a = 12 b=’py’ c=’a’
‘{2}{0}.{1}’.format(a, b, c) # ‘a12.py’
3、format的简写方式：
格式：f’{变量1}{变量2}{变量3}’
要求：python 3.6以上版本
2、列表【list】
1、作用：用于数据的存储，同时，对存储的数据进行操作
2、概念：
1、可以存储任意类型的数据
2、列表是一个可变的序列
3、列表中的元素前后是无关联，但是有先后顺序
3、表示方式
用 [] 表示
4、创建方式
1、空列表
格式：变量 = []
变量 = list()
2、非空列表
[2, 3.23, 5j, True, ‘python’, [1, 4]]
格式：list(可迭代对象)
list(range(8))
list(‘python’)
5、列表的运算符
1、算术/复合运算符
+ * += *=
+ 用于列表的拼接，不会改变原列表，会改变数据的内存存储地址
* 将列表重复多少次，不会改变原列表，会改变数据的内存存储地址
+= 用于列表的拼接，会改变原列表，不会改变数据的内存存储地址
*= 将列表重复多少次，会改变原列表，不会改变数据的内存存储地址
2、比较运算符
符号：> >= < <= == !=
实例
>>> L1 # [1, 3, 2, 4]
>>> L2 # [2, 4]
>>> L1 > L2 # False
3、in not in运算符
格式：sub in/not in list
作用：用于判断某个元素是否在列表中
6、列表的索引：
格式：list[index]
正向：index从0开始
反向：index从-1开始
>>> L3 # [1, 3, 5, [2, 6, 8]]
>>> L3[-1][1] # 6
len(list) 查看当前列表的长度
7、列表中元素的操作
1、修改：
格式：list[index] = value
2、删除
格式：del list[index]
8、列表的切片
与字符串的切片方式一致
格式：list[[start_index]:[stop_index][:step]]
9、列表的索引
1、格式：list[index]
2、操作：
1、修改：list[index] = value
2、删除：del list[index]
10、列表的切片
1、格式：list[[start_index]:[stop_index][:step]]
2、操作：
1、修改：
格式：list[[start_index]:[stop_index][:step]] = 可迭代对象
注意：当步长为1时，值的元素个数可以不与列表的切片元素个数相同，当步长大于1时，值的元素个数必须与切片的元素个数相同
2、删除
格式：del list[[start_index]:[stop_index][:step]]
11、内置函数：
sum(可迭代对象) 计算可迭代对象中的元素的和【元素必须是int/float】
all(list) 真值判断，列表中的元素全为真时，返回为True
any(list) 真值判断，列表中的元素只有有一个为真，则返回为True
len(list) 计算列表的长度
12、列表的遍历
格式：for 变量 in list:
语句
作用：将列表中的每个元素遍历一次
13、常用方法：
list –》 L
dir(list) 查看列表中拥有的方法
方法 描述
L.append(sub) 向列表中添加一个元素置末尾
L.clear() 清空列表
L.copy() 将列表拷贝一份
L.count(sub) 计算某个元素出现的次数
L.extend(L2) 将L2追加L中
L.index(sub, [start, stop]) 获取范围内元素对应的索引值
L.insert(index, sub) 将元素插入到指定位置
L.pop([index]) 返回删除的元素，可以指定删除元素的索引值，如果不设置index，则默认从列表的最后位置开始删除
L.remove(sub) 删除指定的元素，如果元素不在列表中，则产生ValueError
L.reverse() 将列表翻转
L.sort(key=None, reverse=False) 按照一定规则将列表按照从小到大排序
key:排序的依据，值为函数名
reverse:默认从小到大，True:从大到小
练习：
输入一个长字符串，计算每个元素出现的次数，并打印出来：
如：java j：1 a:2 v:1
14、浅拷贝与深拷贝
1、浅拷贝
指的是重新开辟一片内存，用于存储拷贝的数据，拷贝第一层的数据，拷贝第二层数据的内存存储地址。
说明：拷贝前后内存存储地址会发生变化，同时，如果对第二层数据进行修改，则拷贝的对象中数据也会发生变化。
>>> L = [1, 4, 7, [3, 6]]
>>> id(L) # 2734215018760
>>> L1 = L.copy()
>>> id(L1) # 2734211048264
>>> L # [1, 4, 7, [3, 6]]
>>> L1 # [1, 4, 7, [3, 6]]
>>> L[1] = ‘four’
>>> L # [1, ‘four’, 7, [3, 6]]
>>> L1 # [1, 4, 7, [3, 6]]
>>> L[-1][1] = ‘six’
>>> L # [1, ‘four’, 7, [3, ‘six’]]
>>> L1 # [1, 4, 7, [3, ‘six’]]
2、深拷贝
指的是完全的将数据拷贝一份存储到新的地址内存中。
说明：拷贝前后的存储地址发生变化，深拷贝不会受到源数据的影响。
>>> from copy import deepcopy
>>> L3 # [1, 3, [2, ‘four’, 6]]
>>> id(L3) # 2734211048392
>>> L4 = deepcopy(L3)
>>> L4 # [1, 3, [2, ‘four’, 6]]
>>>id(L4) # 2734214949128
>>> L3[1] = ‘python’
>>> L3 # [1, ‘python’, [2, ‘four’, 6]]
>>> L4 # [1, 3, [2, ‘four’, 6]]
>>> L3[-1][0] = ‘python’
>>> L3 # [1, ‘python’, [‘python’, ‘four’, 6]]
>>> L4 # [1, 3, [2, ‘four’, 6]]
3、区别：
浅拷贝：内存存储地址发生变化。会受到源数据的影响
深拷贝：内存存储地址发生变化。不会受到源数据的影响
4、作用
1、减少对计算机内存的占用
2、防止数据的丢失
15、列表推导式
格式：[变量 for 变量 in 可迭代对象]
[变量 for 变量 in 可迭代对象 if 条件表达式]
流程：
1、for循环
2、if语句
3、存储变量
L = list(range(10))
print(L)
L1 = []
for i in range(10):
if i % 2 == 1:
L1.append(i)
print(L1)
print([i for i in range(10)])
print([j for j in range(10) if j%2==1])
16、列表推导式的嵌套：
格式：[变量 for 变量 in 可迭代对象
for 变量 in 可迭代对象]
[变量 for 变量 in 可迭代对象 if 条件表达式
for 变量 in 可迭代对象 if 条件表达式]
说明：
前面的for表示的外层循环，后面的是内层循环
# [‘A1’, ‘A2’, ‘A3’, ‘B1’, ‘B2’, ‘B3’, ‘C1’, ‘C2’, ‘C3’]
L3 = []
for a in ‘ABC’:
for b in ‘123’:
L3.append(a+b)
print(L3)
print(‘嵌套：’, [a+b for a in ‘ABC’ for b in ‘123’])
2、元组【tuple】
1、作用：保证数据安全性的存储容器
2、概念：
1、元组是不可变的容器，可以存储任意类型的值
2、存储的元素是有先后顺序的【索引/切片】
3、表示方式
用 （） 表示，如果元组中只有一个元素时，要在括号中加 ,
4、创建方式：
1、空元组：
格式：变量 = （）
变量 = tuple()
2、非空元组：
t1 = (32, )
t2 = 3, 4, 5
t3 = (3, 3.2, 2+4j, False, ‘python’, [1, 3], (3, 5))
内建函数格式：
tuple(可迭代对象)
t4 = tuple(range(5))
t4 = tuple(‘python’)
t4 = tuple(list(range(5)))
5、元组的运算
+ += * *= < > >= <= == != in not in
+
6、元组的索引：
格式：tuple[index]
可变序列：list/dict/set
不可变序列：int/float/complex/bool/str/tuple
可变的序列是允许对数据进行操作的
非得修改tuple中的值：
不可变的数据类型 可变的数据类型
tuple –> list tuple
7、元组的切片
格式：tuple[[start_index]:[stop_index][:step]]
8、元组中常用方法：
tuple –》T
dir(tuple) 查看当前元组的拥有的方法
help(tuple.method) 查看元组方法的使用
方法 描述
T.index(sub, [start, end]) 获取元组中元素的下标【索引值】
T.count(sub) 计算某个元素出现的次数
3、字典【dict】
1、作用：快速的通过键找到对应的值
2、概念：
1、字典是一种可变的容器，可以存储数据
2、字典是以键值对的方式存储数据，键与值之间使用 : 连接
3、键只能是不可变的数据类型，且键不能重复
4、字典的存储是无序
5、字典是通过键进行索引的
3、表示方式
字典是以 {} 表示，数据是以：{key:value, key:value}
4、创建方式
1、空字典
格式：变量 = {}
变量 = dict()
2、非空字典
{4:[‘four’], 3.23:(‘float’,), ‘a’:1}
内建函数：
dict(可迭代对象)
dict([(‘a’, ‘b’)])
dict([(‘a’, ‘b’), ‘AB’])
dict(a=2, b=4, c=8)
>>> L = [‘a’, ‘b’, ‘c’]
>>> L1 = [1, 3, 5]
>>> dict(zip(L, L1))
5、字典的基本操作【增删改查（CRUD）】
1、增加：
格式：dict[key]
增加键值对的格式：dict[key] = value
注意：键值对不存在时，是表示向字典中增加键值对
2、修改：
修改字典中键值对的格式：dict[key] = value
注意：键值对存在时，修改字典中的键所对应的值
3、删除：
格式：del dict[key]
4、查找：
格式：key in/not in dict
作用：判断键是否在字典中
6、字典的常用方法：
dict –》D
方法 描述
D.clear() 清空字典
D.copy() 将字典复制一份
D.fromkeys(iterable, value=None) 将可迭代对象中的数据作为字典的键，value是表示字典的值
D.get(key, [default]) 如果键存在，则返回键所对应的值，否则返回默认值default
D.items() 返回字典中所有以 [(key, value)，…] 形式
D.keys() 获取字典中所有的键
D.values() 获取字典中所有的值
D.pop(key, [default]) 返回键对应的值，如果键不存在，同时未设置默认值，则产生KeyError，如果设置了默认值，在未找到key时，返回default值
D.update(d1) 将一个字典更新另一个字典中
7、字典的遍历
1、格式1：
for 变量 in dict:
语句块
注意：此遍历方式返回的是字典的键
2、格式2：
for 变量1，变量2 in dict.items():
语句块
8、字典推导式：
格式：{键表达式：值表达式 for 变量 in 可迭代对象}
{键表达式：值表达式 for 变量 in 可迭代对象 if 条件表达式}
练习：
循环输入字符串，当输入为空时，结束输入：
{‘输入的字符串’:长度， ….}
要求：
字符串：str 长度：len
以以上格式输出.
9、列表与字典
创建方式 索引方式 相同点
字典 {} dict[key] 可以存储数据，可变【对数据进行修改】
列表 [] list[index]
4、集合【set】
1、作用：优化数据的存储方式【数据不能重复】
2、概念：
1、集合是一个可变的序列
2、集合中的数据是唯一【不能重复】
3、集合是一个无序
4、集合内的元素必须是不可变的数据类型
3、表示方式
用 {} 表示，集合内的值是单个元素
4、创建方式
1、空集合
格式：变量 = set()
2、非空集合
内建函数：
set(iterable)
set(dict(a=3, b=5)) # {‘b’, ‘a’}
5、集合的运算符
集合运算符 描述
& 交集
| 并集
- 补集
> 全集
< 子集
== 等号
！= 不等号
in not in 在/不在
练习：
英雄：李逵、林冲、卢俊义
好汉：宋江、林冲、李逵、武松
1、既是英雄也是好汉的有？
2、是英雄，不是好汉的有？
3、只有一个称谓有谁？同时有几个人？
6、集合的常用方法
set –》 S
方法 描述
S.add(sub) 向集合中添加一个元素
S.remove(sub) 删除指定的元素,如果元素不存在，则产生KeyError
S.pop() 删除集合中的随机元素
S.discard(sub) 删除指定的元素，如果元素不存在，则返回为空
S.copy() 将集合拷贝一遍
S.update(s1) 将s1更新到s中
7、集合的遍历：
格式：for 变量 in set:
语句块
8、集合的推导式
格式：{表达式 for 变量 in 可迭代对象}
{表达式 for 变量 in 可迭代对象 if 条件表达式}
1、字符串【str】
1、概念：
用来记录文本信息
2、表示方法：
‘’ “ ” ‘’’ ‘’’ “”” ”””
‘’：用的最多，单引号用可以套用双引号
print(‘我说：“你好”’)
“”：双引号中是可以套用单引号
print(“This’s a book”)
“”” “”” ‘’’ ’’’：多行注释、文档字符串【函数或实例方法中做功能的解释说明】，默认的换行功能
\ 换行符
3、特殊字符：
Python解释器在解释其内容是会将特殊字符进行转义：
\n 换行符
\t 制表符【默认是8个空格】
\r 将光标返回首行
\’ ’
\
源字符【Raw】:
作用：将特殊字符的转义功能失效
格式：r’’ r”” r””” ””” r’’’ ’’’
示例：
print(r’’‘C:\nate\teacher\read’’’) # C:\nate\teacher\read
4、字符串的拼接与分割
1、分割
str.split([sep]) # 按照sep【分割的依据】分割字符串，当sep参数不设置是表示按照空格分割，不限制空格的数量
返回值：列表【list】
示例：
s = ‘s+t+r+i+n+g’ s.split(sep=’+’) # [‘s’, ‘t’, ‘r’, ‘i’, ‘n’, ‘g’]
>>> s1 = ‘s d d g i’
>>> s1.split(sep=’ ') # [‘s’, ‘d’, ‘’, ‘d’, ‘’, ‘g’, ‘i’]
>>> s1.split() # [‘s’, ‘d’, ‘d’, ‘g’, ‘i’]
2、拼接：
1、+
>>> ‘hello’ + ‘world’ # ‘helloworld’
2、靠近
>>> ‘hello’‘world’ # ‘helloworld’
3、join函数
格式：‘连接符’.join(字符串)
>>> s = ‘abc’
>>> ‘+’.join(s) # ‘a+b+c’
5、字符串的运算
1、算术运算符
+ *
+ ： 字符串的拼接，不会改变原字符串
* : 将字符串重复一定的次数，不会改变原字符串
格式：‘str’* num【次数(int)】
示例：
>>> ‘abc’ * 4 # ‘abcabcabcabc’
>>> ‘abcabc’ + ‘a’ # ‘abcabca’
2、复合运算符：
+= *=
+= ：字符串的拼接，会改变原字符串
*= ：将字符串重复一定的次数，会改变原字符串
示例：
>>> s # ‘abc’
>>> s += ‘abc’
>>> s # ‘abcabc’
>>> s *= 3
>>> s # ‘abcabcabcabcabcabc’
3、比较运算符：
符号：< <= > >= == !=
比较依据：按照对应位置上的字符的Unicode值的大小进行比较
内置函数：
ord(sub) 查看当前字符的Unicode值
chr(code) 根据Unicode值返回对应的字符
练习：
1、打印‘abc…z’
2、打印‘AaBb….Zz’
6、in not in运算符
作用：用于判断某个对象是否在序列中
格式：obj in/not in 序列
序列：str/list/tuple/dict/set
返回值：布尔类型【bool】
说明：not in与in正好相反
>>> s = 'abscdd'
>>> 'a' in s # True
1
2
7、字符串的索引
格式：str[index]
说明：index【索引值】，字符串的第一个字符的索引值为0，第二个索引值为1，……最后的一个字符的索引值：len(str)-1 -索引值为正
字符串的第一个字符的索引值为：-1，第二个的索引值为：-2, …最后一个字符的索引值为：-len(str) -> 索引值为负
List item
内置函数：
len(序列) 获取当前序列的长度
实例：
str P Y T H O N
正向索引值 0 1 2 3 4 5
反向索引值 -6 -5 -4 -3 -2 -1
原则：‘就近原则’
缺点：只能通过索引值取出对应字符串中的一个字符
7、字符串的切片
作用：通过切片的方式获取字符串中连续或一定间隔的字符
格式：str[[strart_index]:[stop_index][:step]]
参数：
start_index: 表示切片的起始位置，可以不设置，则：
正向切片：表示字符串的开头位置
反向切片：表示字符串的末尾位置
stop_index: 表示切片的终止位置，对应的值取不到，可以不设置，则：
正向切片：表示字符串的末尾位置
反向切片：表示字符串的起始位置
step: 表示切片的偏移量或间隔【步长】，可以不设置，默认为为1，可正可负
正：正向切片
负：反向切片
练习：
s = ‘abcdefg’
s[3] # ‘d’
s[:-5] # ’ab’
s[-3:2] # ‘’
s[-4:7:2] # ‘df’
s[-3:6:-3] # ’’
9、字符串的遍历
格式：for 变量 in 非空的字符串：
语句块
10、字符串常用的方法
str –》 S
内置函数：dir(obj) 查看当前对象拥有的方法
方法 描述
S. isalpha() 判断当前字符串是否全是字母
S.isdigit() 判断当前字符串是否全是数字
S.isspace() 判断当前字符串是否为空格字符串
S.upper() 将当前字符串中的字母全部转化为大写
S.lower() 将当前字符串中的字母全部转化为小写
S.strip() 去除字符串左右的空白
S.lstrip() 去除字符串左侧的空白
S.rstrip() 去除字符串右侧的空白
S.center(width, [fillchar]) 按照一定的宽度将字符串居中，如果宽度大于字符串的长度时，可以设置fill的值用于填充空白
S.count(sub, [start, end]) 按照指定范围查找当前字符出现的次数
S.find(sub, [start, end]) 返回对应区间内字符的索引值【默认从左至右查找】，如果查找的字符不存在，则返回-1
S.index(sub, [start, end]) 返回对应区间内字符的索引值【默认从左至右查找】，如果查找的字符不存在，产生ValueError
S.replace(old, new, [count]) 从左至右将旧的字符替换为新的字符，如果不设置count值，默认全部替换，同时，替换的字符不存在，则返回原字符串
help(str.method) # 返回字符串方法的使用
练习：
1、用户输入的是数字，将结果进行5次方，并打印
2、用户输入的是字母，将其转化为大写，按照20个宽度居中，并打印
3、如果用户输入为空或为未输入，结束输入
4、如果用户输入的是浮点数，则将其保留两位小数并打印
11、格式化字符串
1、格式1：
格式：‘占位符’ % value
‘占位符1, 占位符2, …’ % (value1, value2, …)
说明：占位符要与值个数相同
占位符：
%d 十进制的整数
%f 十进制浮点数
%s 字符串
修饰符：
1、 左对齐
0 用于填充左侧空白【不能与0同时使用】
%-nd n 表示的是显示整型的宽度， - 左对齐【宽度小于整型的长度时，则宽度无效】
%-m.nf m 表示的浮点数显示的宽度，n表示的保留浮点数的位数
%ns n 表示的字符串显示的宽度
2、格式2：
格式：’{} {} …’.format(v1, v2, ….)
‘{编号2} {编号1} {编号…}’.format(v0, v1, v2, …)
a = 12 b=’py’ c=’a’
‘{2}{0}.{1}’.format(a, b, c) # ‘a12.py’
3、format的简写方式：
格式：f’{变量1}{变量2}{变量3}’
要求：python 3.6以上版本
2、列表【list】
1、作用：用于数据的存储，同时，对存储的数据进行操作
2、概念：
1、可以存储任意类型的数据
2、列表是一个可变的序列
3、列表中的元素前后是无关联，但是有先后顺序
3、表示方式
用 [] 表示
4、创建方式
1、空列表
格式：变量 = []
变量 = list()
2、非空列表
[2, 3.23, 5j, True, ‘python’, [1, 4]]
格式：list(可迭代对象)
list(range(8))
list(‘python’)
5、列表的运算符
1、算术/复合运算符
+ * += *=
+ 用于列表的拼接，不会改变原列表，会改变数据的内存存储地址
* 将列表重复多少次，不会改变原列表，会改变数据的内存存储地址
+= 用于列表的拼接，会改变原列表，不会改变数据的内存存储地址
*= 将列表重复多少次，会改变原列表，不会改变数据的内存存储地址
2、比较运算符
符号：> >= < <= == !=
实例
>>> L1 # [1, 3, 2, 4]
>>> L2 # [2, 4]
>>> L1 > L2 # False
3、in not in运算符
格式：sub in/not in list
作用：用于判断某个元素是否在列表中
6、列表的索引：
格式：list[index]
正向：index从0开始
反向：index从-1开始
>>> L3 # [1, 3, 5, [2, 6, 8]]
>>> L3[-1][1] # 6
len(list) 查看当前列表的长度
7、列表中元素的操作
1、修改：
格式：list[index] = value
2、删除
格式：del list[index]
8、列表的切片
与字符串的切片方式一致
格式：list[[start_index]:[stop_index][:step]]
9、列表的索引
1、格式：list[index]
2、操作：
1、修改：list[index] = value
2、删除：del list[index]
10、列表的切片
1、格式：list[[start_index]:[stop_index][:step]]
2、操作：
1、修改：
格式：list[[start_index]:[stop_index][:step]] = 可迭代对象
注意：当步长为1时，值的元素个数可以不与列表的切片元素个数相同，当步长大于1时，值的元素个数必须与切片的元素个数相同
2、删除
格式：del list[[start_index]:[stop_index][:step]]
11、内置函数：
sum(可迭代对象) 计算可迭代对象中的元素的和【元素必须是int/float】
all(list) 真值判断，列表中的元素全为真时，返回为True
any(list) 真值判断，列表中的元素只有有一个为真，则返回为True
len(list) 计算列表的长度
12、列表的遍历
格式：for 变量 in list:
语句
作用：将列表中的每个元素遍历一次
13、常用方法：
list –》 L
dir(list) 查看列表中拥有的方法
方法 描述
L.append(sub) 向列表中添加一个元素置末尾
L.clear() 清空列表
L.copy() 将列表拷贝一份
L.count(sub) 计算某个元素出现的次数
L.extend(L2) 将L2追加L中
L.index(sub, [start, stop]) 获取范围内元素对应的索引值
L.insert(index, sub) 将元素插入到指定位置
L.pop([index]) 返回删除的元素，可以指定删除元素的索引值，如果不设置index，则默认从列表的最后位置开始删除
L.remove(sub) 删除指定的元素，如果元素不在列表中，则产生ValueError
L.reverse() 将列表翻转
L.sort(key=None, reverse=False) 按照一定规则将列表按照从小到大排序
key:排序的依据，值为函数名
reverse:默认从小到大，True:从大到小
练习：
输入一个长字符串，计算每个元素出现的次数，并打印出来：
如：java j：1 a:2 v:1
14、浅拷贝与深拷贝
1、浅拷贝
指的是重新开辟一片内存，用于存储拷贝的数据，拷贝第一层的数据，拷贝第二层数据的内存存储地址。
说明：拷贝前后内存存储地址会发生变化，同时，如果对第二层数据进行修改，则拷贝的对象中数据也会发生变化。
>>> L = [1, 4, 7, [3, 6]]
>>> id(L) # 2734215018760
>>> L1 = L.copy()
>>> id(L1) # 2734211048264
>>> L # [1, 4, 7, [3, 6]]
>>> L1 # [1, 4, 7, [3, 6]]
>>> L[1] = ‘four’
>>> L # [1, ‘four’, 7, [3, 6]]
>>> L1 # [1, 4, 7, [3, 6]]
>>> L[-1][1] = ‘six’
>>> L # [1, ‘four’, 7, [3, ‘six’]]
>>> L1 # [1, 4, 7, [3, ‘six’]]
2、深拷贝
指的是完全的将数据拷贝一份存储到新的地址内存中。
说明：拷贝前后的存储地址发生变化，深拷贝不会受到源数据的影响。
>>> from copy import deepcopy
>>> L3 # [1, 3, [2, ‘four’, 6]]
>>> id(L3) # 2734211048392
>>> L4 = deepcopy(L3)
>>> L4 # [1, 3, [2, ‘four’, 6]]
>>>id(L4) # 2734214949128
>>> L3[1] = ‘python’
>>> L3 # [1, ‘python’, [2, ‘four’, 6]]
>>> L4 # [1, 3, [2, ‘four’, 6]]
>>> L3[-1][0] = ‘python’
>>> L3 # [1, ‘python’, [‘python’, ‘four’, 6]]
>>> L4 # [1, 3, [2, ‘four’, 6]]
3、区别：
浅拷贝：内存存储地址发生变化。会受到源数据的影响
深拷贝：内存存储地址发生变化。不会受到源数据的影响
4、作用
1、减少对计算机内存的占用
2、防止数据的丢失
15、列表推导式
格式：[变量 for 变量 in 可迭代对象]
[变量 for 变量 in 可迭代对象 if 条件表达式]
流程：
1、for循环
2、if语句
3、存储变量
L = list(range(10))
print(L)
L1 = []
for i in range(10):
if i % 2 == 1:
L1.append(i)
print(L1)
print([i for i in range(10)])
print([j for j in range(10) if j%2==1])
16、列表推导式的嵌套：
格式：[变量 for 变量 in 可迭代对象
for 变量 in 可迭代对象]
[变量 for 变量 in 可迭代对象 if 条件表达式
for 变量 in 可迭代对象 if 条件表达式]
说明：
前面的for表示的外层循环，后面的是内层循环
# [‘A1’, ‘A2’, ‘A3’, ‘B1’, ‘B2’, ‘B3’, ‘C1’, ‘C2’, ‘C3’]
L3 = []
for a in ‘ABC’:
for b in ‘123’:
L3.append(a+b)
print(L3)
print(‘嵌套：’, [a+b for a in ‘ABC’ for b in ‘123’])
2、元组【tuple】
1、作用：保证数据安全性的存储容器
2、概念：
1、元组是不可变的容器，可以存储任意类型的值
2、存储的元素是有先后顺序的【索引/切片】
3、表示方式
用 （） 表示，如果元组中只有一个元素时，要在括号中加 ,
4、创建方式：
1、空元组：
格式：变量 = （）
变量 = tuple()
2、非空元组：
t1 = (32, )
t2 = 3, 4, 5
t3 = (3, 3.2, 2+4j, False, ‘python’, [1, 3], (3, 5))
内建函数格式：
tuple(可迭代对象)
t4 = tuple(range(5))
t4 = tuple(‘python’)
t4 = tuple(list(range(5)))
5、元组的运算
+ += * *= < > >= <= == != in not in
+
6、元组的索引：
格式：tuple[index]
可变序列：list/dict/set
不可变序列：int/float/complex/bool/str/tuple
可变的序列是允许对数据进行操作的
非得修改tuple中的值：
不可变的数据类型 可变的数据类型
tuple –> list tuple
7、元组的切片
格式：tuple[[start_index]:[stop_index][:step]]
8、元组中常用方法：
tuple –》T
dir(tuple) 查看当前元组的拥有的方法
help(tuple.method) 查看元组方法的使用
方法 描述
T.index(sub, [start, end]) 获取元组中元素的下标【索引值】
T.count(sub) 计算某个元素出现的次数
3、字典【dict】
1、作用：快速的通过键找到对应的值
2、概念：
1、字典是一种可变的容器，可以存储数据
2、字典是以键值对的方式存储数据，键与值之间使用 : 连接
3、键只能是不可变的数据类型，且键不能重复
4、字典的存储是无序
5、字典是通过键进行索引的
3、表示方式
字典是以 {} 表示，数据是以：{key:value, key:value}
4、创建方式
1、空字典
格式：变量 = {}
变量 = dict()
2、非空字典
{4:[‘four’], 3.23:(‘float’,), ‘a’:1}
内建函数：
dict(可迭代对象)
dict([(‘a’, ‘b’)])
dict([(‘a’, ‘b’), ‘AB’])
dict(a=2, b=4, c=8)
>>> L = [‘a’, ‘b’, ‘c’]
>>> L1 = [1, 3, 5]
>>> dict(zip(L, L1))
5、字典的基本操作【增删改查（CRUD）】
1、增加：
格式：dict[key]
增加键值对的格式：dict[key] = value
注意：键值对不存在时，是表示向字典中增加键值对
2、修改：
修改字典中键值对的格式：dict[key] = value
注意：键值对存在时，修改字典中的键所对应的值
3、删除：
格式：del dict[key]
4、查找：
格式：key in/not in dict
作用：判断键是否在字典中
6、字典的常用方法：
dict –》D
方法 描述
D.clear() 清空字典
D.copy() 将字典复制一份
D.fromkeys(iterable, value=None) 将可迭代对象中的数据作为字典的键，value是表示字典的值
D.get(key, [default]) 如果键存在，则返回键所对应的值，否则返回默认值default
D.items() 返回字典中所有以 [(key, value)，…] 形式
D.keys() 获取字典中所有的键
D.values() 获取字典中所有的值
D.pop(key, [default]) 返回键对应的值，如果键不存在，同时未设置默认值，则产生KeyError，如果设置了默认值，在未找到key时，返回default值
D.update(d1) 将一个字典更新另一个字典中
7、字典的遍历
1、格式1：
for 变量 in dict:
语句块
注意：此遍历方式返回的是字典的键
2、格式2：
for 变量1，变量2 in dict.items():
语句块
8、字典推导式：
格式：{键表达式：值表达式 for 变量 in 可迭代对象}
{键表达式：值表达式 for 变量 in 可迭代对象 if 条件表达式}
练习：
循环输入字符串，当输入为空时，结束输入：
{‘输入的字符串’:长度， ….}
要求：
字符串：str 长度：len
以以上格式输出.
9、列表与字典
创建方式 索引方式 相同点
字典 {} dict[key] 可以存储数据，可变【对数据进行修改】
列表 [] list[index]
4、集合【set】
1、作用：优化数据的存储方式【数据不能重复】
2、概念：
1、集合是一个可变的序列
2、集合中的数据是唯一【不能重复】
3、集合是一个无序
4、集合内的元素必须是不可变的数据类型
3、表示方式
用 {} 表示，集合内的值是单个元素
4、创建方式
1、空集合
格式：变量 = set()
2、非空集合
内建函数：
set(iterable)
set(dict(a=3, b=5)) # {‘b’, ‘a’}
5、集合的运算符
集合运算符 描述
& 交集
| 并集
- 补集
> 全集
< 子集
== 等号
！= 不等号
in not in 在/不在
练习：
英雄：李逵、林冲、卢俊义
好汉：宋江、林冲、李逵、武松
1、既是英雄也是好汉的有？
2、是英雄，不是好汉的有？
3、只有一个称谓有谁？同时有几个人？
6、集合的常用方法
set –》 S
方法 描述
S.add(sub) 向集合中添加一个元素
S.remove(sub) 删除指定的元素,如果元素不存在，则产生KeyError
S.pop() 删除集合中的随机元素
S.discard(sub) 删除指定的元素，如果元素不存在，则返回为空
S.copy() 将集合拷贝一遍
S.update(s1) 将s1更新到s中
7、集合的遍历：
格式：for 变量 in set:
语句块
8、集合的推导式
格式：{表达式 for 变量 in 可迭代对象}
{表达式 for 变量 in 可迭代对象 if 条件表达式}