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 条件表达式}