Python基础 1.3 容器类型

1.3 容器类型

1.3.1 字符串 和 修改方法（str）

​ 字符串可以用单引号，双引号，三引号。三引号在特殊情况有优势，比如允许一个字符串跨多行，可以包含换行符制表符以及其他特殊字符。

>>> name1,name2,name3 = "Tom","Jerry","Finch"
>>> name1
'Tom'
>>> name2
'Jerry'
>>> name3
'Finch'

1.字符串切片以及读取

​ 字符串每个字符对应一个下标，可以通过下标读取字符串里的内容，左闭右开，但是如果超出范围会报错

>>> a = "Well Done"
>>> a[:3]
'Wel'
>>> a[:]
'Well Done'
>>> a[4:]
' Done'
>>> a[:20]
'Well Done'
>>> a[13]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

带步长的切片读取

>>> a[::2]
'Wl oe'

负下标读取，变成从右往左读取

>>> a[-1]
'e'
>>> a[-4:-1]
'Don'

2.字符串的查

1) count 检查字符串里某字符出现的次数

其中str代表的是要检查的字符串，sub代表的是要检查的某字符

start和end可以选加入

str.count(sub, start= 0,end=len(string))
>>> a="www.baidu.com"
>>> b="baidu"
>>> a.count(b)
1
>>> a.count(b,0,2)
0

2) find 检查字符串里某字符是否出现，如果有则返回索引值，如果没有返回-1

str.count(sub, start= 0,end=len(string))
>>> a="www.google.com"
>>> b="google"
>>> a.find(b)
4
>>> c="baidu"
>>> a.find(c)
-1

3) index 和find用法相同，查询某字符是否出现并且返回索引值，如果没有返回异常

>>> a.index(b,0,5) #记住区间查询是左闭右开
4
>>> a.index(c)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

4) isdigit 检查是否全部为数字，返回bool

>>> a.isdigit()
False

5) isalpha 检查是否全部为字母，返回bool

>>> b.isalpha()
True

6) endswith 检查字符串是否以某字符或者元素结尾，返回bool

str.endswith(sub[, start[, end]]);
>>> a="Mission Completed! Well Done!"
>>> b="Done!"
>>> a.endswith(b,5)
True
>>> a.endswith(b,2,5)
False

7) startswith 检查字符串是否以某元素或者字符开头，返回bool

str.startswith(strw, beg=0,end=len(string));
>>> c="Com"
>>> a.startswith(c,8,20)
True
>>> a.startswith(c)
False

8) islower 检查字符串是否为小写

9) isupper 检查字符串是否为大写

>>> a="Well Done"
>>> a.islower()
False
>>> b="well done"
>>> b.islower()
True
>>> c="WELL DONE"
>>> c.isupper()
True

3.字符串的修改

​ 所有字符串相关的更改是返回新地址的，不会修改到原有的值。

​ 1) upper 将字符串里所有字母变为大写

​ 2) lower 将字符串里所有字母变为小写

>>> b = "well 01 done"
>>> b.upper()
'WELL 01 DONE'
>>> b.lower()
'well 01 done'

​ 3) strip 移除字符串头尾指定的字符，默认是空格，无法删除中间的字符

>>> a = "  ---Well Done!---  "
>>> a.strip()
'---Well Done!---'
>>> a
'  ---Well Done!---  '
>>> a = a.strip()
>>> a.strip('---')
'Well Done!'

​ 4) captialize 将首字母大写，如果首位不是字母则不生效

>>> a.capitalize()
'App01'
>>> a ="01app"
>>> a.capitalize()
'01app'

​ 5) title 将所有单词的首字母大写

>>> a="you got it, dude"
>>> a.title()
'You Got It, Dude'

​ 6) split 以选定的字符或者序列为分割线（默认不填是空格），将字符串切割成2组或者多组字符串，返回列表

>>> a="The Great King Trump"
>>> a.split() # 默认全部分割，可以填入maxsplit = 次数
['The', 'Great', 'King', 'Trump']
>>> a.split('T')
['', 'he Great King ', 'rump']
>>> a.split('T',1)
['', 'he Great King Trump']
# 选择第一个T为切割线

​ 8)replace 替换指定的字符或者字符序列

>>> a="yes yes yes yes yes no"
>>> a.replace('yes','no'，5) # 可以指定替换次数，默认全部
'no no no no no no'

9)list.ljust(字符串宽度，填充字符) 按照指定宽度返回新字符串，基于原字符串向左对齐，可设置2边空白填充

10)list.rjust(字符串宽度，填充字符) 按照指定宽度返回新字符串，基于原字符串向右对齐，可设置2边空白填充

11. list.lstrip(目标字符串) 返回新字符串，去除 字符串 右边的目标字符串, 不设置目标字符串则去除空格

12. list.rstrip(目标字符串) 返回新字符串，去除 字符串 左边的目标字符串, 不设置目标字符串则去除空格

4.字符串其他操作

​ 1) 字符串的合并

>>> a="s s s"
>>> b="h h h"
>>> c=a[:2]+b
>>> c
's h h h'

​ 2) 列表的合并成字符串

list=['k', 'k', 'l', '5']
str_null = " "
new_str = str_null.join(list)

​

​ 2) 获取字符串长度

a ="jiasoihauiqhow"
>>> len(a)
14

​ 3) 重复输出字符串

>>> print(a*2)
jiasoihauiqhowjiasoihauiqhow

​ 4) 格式化字符串

print("ssss%s %d %f" % (str,int,float))
print(f"ssss{str} {int} {float}")
print(F"ssss{str} {int} {float}")
print("ssss{} {} {}.format(str,int,float)")

​ 5) 用r来控制转义符，使其不生效

>>> print('C:\bed')
Ced
>>> print(r'C:\bed')
C:\bed

6. list.partition(分割符) 选取一个片段亦或者一个字符作为分隔符，将字符串切割成3样组成元组返回

1.3.2 集合（set）

​ 集合用{}定义，元素之间用,分隔，和其他不一样的是，集合里的元素是唯一的，所以可以通过转化来帮助其他列表元组去重。

li = [5, 2, 3, 4, 2, 7, 9, 10, 2, 5]
a = set(li)
print(a)
# 转化成集合
li = list(a)
print(li)
# 再次转化回列表，已经完成去重

1.3.3 列表（li）

​ 是python里使用最频繁的数据类型，可以完成大部分集合类数据结构实现，支持数字，字符，字符串，也支持列表嵌套。列表和字符串一样，每个里面的元素都对应一个下标，从左到右是从0开始计数，从右到左则是从-1开始计数。也就是可以靠下标来读取列表里的值。

1.列表的查和循环遍历

# 遍历，从头开始找，直到结束
name_list = ['mike', 'yoyo', 'rock', 'lily']

# 通过while实现遍历
# 1. 定义条件变量i = 0
i = 0

# 2. while i < 列表元素个数:
while i < len(name_list):
    # 3. 取出某个元素，打印
    name = name_list[i]
    print(name)

    # 4. 条件变量的修改
    i += 1

print('==========华丽分割线=============')

# for遍历循环，和上面的while效果等价
# 从头到尾 依次从 列表 中取出 每一个元素
for name in name_list:
    print(name)

1.列表的增加方法

append 增加一项目，无法指定位置，多项目会报错，

insert 在指定位置增加项目，

extend 只能插入列表元组字符串，并且是拆开后加进去的。（id地址会保持第一列表不变）

>>> li=[4,2.22,4-5j,'gugu']
>>> li.append('a')
>>> li
[4, 2.22, (4-5j), 'gugu', 'a']
>>> li.append((1,2,3))
>>> li
[4, 2.22, (4-5j), 'gugu', 'a', (1, 2, 3)]
>>> li.append('f','g')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: list.append() takes exactly one argument (2 given)

>>> li.insert(0,999)
>>> li
[999, 4, 2.22, (4-5j), 'gugu', 'a', (1, 2, 3)]
>>> li.insert(999999,888)
>>> li
[999, 4, 2.22, (4-5j), 'gugu', 'a', (1, 2, 3), 888]

>>> li.extend(888)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
>>> li.extend('abc')
>>> li
[999, 4, 2.22, (4-5j), 'gugu', 'a', (1, 2, 3), 888, 'a', 'b', 'c']
>>> li.extend((888,999))
>>> li
[999, 4, 2.22, (4-5j), 'gugu', 'a', (1, 2, 3), 888, 'a', 'b', 'c', 888, 999]

2.列表的删除方法

pop 删除指定位置元素，如果不指定，默认是最后一个元素

remove 删除指定元素，不是指定位置 注意 remove会使得 后面的元素往上移动，导致漏删除

clear 删除全部元素

>>> li=[777,6.8,'gbg',(4-7j)]
>>> li.pop()
(4-7j)
>>> li
[777, 6.8, 'gbg']
>>> li.pop(1)
6.8
>>> li
[777, 'gbg']
>>> li.remove('gbg')
>>> li
[777]
>>> li=[555,666,77,888]
>>> li.clear()
>>> li
[]

3. 列表的修改和其他方法

1 指定位置元素直接赋值修改

2 index 索引 索引元素位置，返回位置值

>>> li=[11,22,33,44,55]
>>> li.index(22)
1

3 count 和字符串一样，计算该元素在列表里出现的次数

4 len 计算长度

5 copy 复制列表

>>> a
[1, 2, 3, 4, 5]
>>> b=a
>>> b
[1, 2, 3, 4, 5]
>>> c=a.copy()
>>> c
[1, 2, 3, 4, 5]
>>> id(a)
2252708673408
>>> id(b)
2252708673408
>>> id(c)
2252708978240
>>> a[0]=0
>>> a
[0, 2, 3, 4, 5]
>>> b
[0, 2, 3, 4, 5]
>>> c
[1, 2, 3, 4, 5]

​ 由此可以看出b和a用的是一个内存位置的数据，因为是赋值，而c是属于复制的，不会因为a的变化而变化。

​ 我们一般叫这个叫浅复制，python实际上自带了模块，有所谓的深复制。

​ 这个和python的数据存储方式有关，在python里我们之前说了，python是强类型语言，任何变量会随着赋值的类型改变而产生改变，那么我们在b=a的时候就也一样把b的赋值指向了这一地址。所以当这一地址的数据改变的时候，b和a一样，会直接显示出改变的数据。但是如果我们把a重新赋值，此时a所指向的地址已经不同于b了，此时对a指向的内容做任何更改，均不会影响到b。

​ 我们重新审视一下copy的结果，在浅复制里，确实简单的内容我们是复制过来的，比如c，c里的东西不会跟着a的变化而变化，但是复杂内容却会，而深复制里，d的任何内容都不会跟着a的变化而变化。这和python的存储也是有关，python对于复杂内容的子对象，会以公共镜像存储，如果只是浅复制和赋值，他们引用的都会是公共镜像，一旦被改变，也会跟着被改变。

>>> import copy
>>> a=[1,2,3,4,5,[7,8]]
>>> b=a
>>> c=a.copy()
>>> d=copy.deepcopy(a)
>>> b
[1, 2, 3, 4, 5, [7, 8]]
>>> c
[1, 2, 3, 4, 5, [7, 8]]
>>> d
[1, 2, 3, 4, 5, [7, 8]]
>>> a[0]=5
>>> a
[5, 2, 3, 4, 5, [7, 8]]
>>> b
[5, 2, 3, 4, 5, [7, 8]]
>>> c
[1, 2, 3, 4, 5, [7, 8]]
>>> d
[1, 2, 3, 4, 5, [7, 8]]
>>> a[5][0]='go'
>>> a
[5, 2, 3, 4, 5, ['go', 8]]
>>> b
[5, 2, 3, 4, 5, ['go', 8]]
>>> c
[1, 2, 3, 4, 5, ['go', 8]]
>>> d
[1, 2, 3, 4, 5, [7, 8]]

​ 上面的可能看不明白，可以看下面列表，可以看出浅复制里，复杂对象的子对象，对应的地址是一致的，深复制不是。

import copy
a = [1, 2, 3, 4, [5, 6, 7]]
b = a.copy()
c = copy.deepcopy(a)
print(id(a[4]))
print(id(b[4]))
print(id(c[4]))

1942906189824
1942906189824
1942906182080

6 reverse 反向列表里的元素（id地址不变）

>>> a= [1,2,4,'white']
>>> a.reverse()
>>> a
['white', 4, 2, 1]

7 sort 排序

list.sort( key=None, reverse=False) 

key指代对比的元素，reverse是指是否颠倒，只能对比普通的数值类型和字母，如果是多种类型的会报错。

8 join 将字符串列表里的每个元素拼接一个字符来形成新的字符串

str1 = ","

name_list = ["beijing", "shenzhen", "shanghai", "guangzhou"]

# 以字符串为连接符拼接字符串列表的元素,生成新的字符串
str2 = str1.join(name_list)
print(str2)  # "beijing,shenzhen,shanghai,guangzhou"

4. 列表的嵌套

>>> a=[1,2,3,4,5]
>>> b=[1,2,3,4]
>>> x=[1,b]
>>> x
[1, [1, 2, 3, 4]]
>>> x=[1,a,b]
>>> x
[1, [1, 2, 3, 4, 5], [1, 2, 3, 4]]

1.3.4 元组（tuple）

​ 元组用()定义，用于存储一串数据即使只包含一个元素的时候也要写一个,隔开，元组和其他非数字数据一样，也有下标。

谨记元组里的元素不能更改，不能删除已有元素，亦不能直接添加元素

空集合的定义为my_set = set()

1.元组的删除查早合并

方法	描述
index()	返回指定元素下标
max	返回元组中最大值元素
min	返回元组中最小值的元素
del	删除整个元组对象
sum	对元组对象所有对象求和

tup_01 = (2, 5, 8, 7, 9, 10, 22, 55)
print(tup_01.index(9))
print(max(tup_01))
print(min(tup_01))
print(sum(tup_01))

4
55
2
118

记住，其中求极值和求和只能用数字，字符串不允许

2.元组的统计

count() 统计元组里某个元素的总数

len() 统计元组里所有元素个数

1.3.5 元组 列表 集合的转换

函数	说明
list(x)	转化为列表
tuple(x)	转化为元组
set(x)	转化为集合

注:字符串转成列表元组和集合时均会每个字符切割成单独元素组成。

1.3.6 字典（dict）

​ 字典是另外一种容器类型，也是一种常用的复合数据结构，谨记，3.5以后的字典属于有序数列。字典每个键值用冒号对应，每个键值逗号隔开。

d = {key1 : value1, key2 : value2 }

​ 键不可变且唯一，键值可变也不用唯一。

1.字典的查方法

1. 最简单的 直接查询对应的键来查询键值

2. values() 查询所有键值，以列表的形式返回

3. keys() 查询所有键，以列表形式返回

4. items() 查询所有键和对应键值，返回元组数组。

5. get() 查找字典里对应键的键值，如果键不存在则返回None或者默认值，如果是字典里嵌套字典，无法通过此方法取得键值。

dict.get(key, default=None)
>>> a={'name':'Tom','age':25,'sex':'male'}
>>> a.get('name')
'Tom'
>>> a.get('career')
>>> a
{'name': 'Tom', 'age': 25, 'sex': 'male'}
>>> a.get('career','none')
'none'

6. setdefault() 和get()类似，区别是如果不存在此键，则会把键添加进去字典，并且设定默认值为对应键值

>>> a.setdefault('career')
>>> a
{'name': 'Tom', 'age': 25, 'sex': 'male', 'career': None}

7. fromkeys() 取出所有键值，由这些键值组成新的字典，默认是none，可以全体赋值，但是不可以单独赋值

>>> dict.fromkeys(a)
{'name': None, 'age': None, 'sex': None, 'career': None}

2.字典的删改方法

1. update 把其他字典里的内容增添到原有字典里

dict.update(dict2)
>>> a
{'name': 'Tom', 'age': 25, 'sex': 'male', 'career': None}
>>> b={'health':'good'}
>>> a.update(b)
>>> a
{'name': 'Tom', 'age': 25, 'sex': 'male', 'career': None, 'health': 'good'}

2. pop() 删除指定键以及对应键值，必须给键，否则返回默认。

3. popitem() 删除最后一对键值，并且返回这对键值，如果字典为空会返回keyerror。

4. del() 和pop相同，但是不会返回任何值。

3.字典的遍历

注意：字典的遍历返回的是字典的迭代器，如果在迭代过程中对字典进行键的删除增加，会报异常。

1.直接使用for变量，获取key值

for key in dict():
	print("key: %s" % key)
	print("values: %s" %dict[key])

2.用for遍历，dict.keys()，也是获取key值。

用法和前面的一样

3.用for遍历,dict.values()获取的是键值。

for v in dict.values()
	print("所有的键值如下 %s" % v)

4.用for遍历，dict.items()，获取所有键和键值。

for k,v in dict.items()
	print(k,v)p

1.3.7 公共语法

1. python内置函数

函数	描述
len()	计算容器中元素个数
max()	返回容器最大值，如是字典只对比key
min()	返回容器最小值，如是字典只对比key

2.切片

切片可以切字符串，列表，元组

记住切片是左开右闭区间

[起始:结束:步长]

3.运算符

运算符	Python 表达式	结果	描述	支持的数据类型
+	[1, 2] + [3, 4]	[1, 2, 3, 4]	合并	字符串、列表、元组
*	[1, 2] * 2	[1, 2, 1, 2]	重复	字符串、列表、元组
in	3 in (1, 2, 3)	True	元素是否存在	字符串、列表、元组、字典
not in	4 not in (1, 2, 3)	True	元素是否不存在	字符串、列表、元组、字典
> >= == < <=	(1, 2, 6) < (1, 3, 4)	True	元素比较	字符串、列表、元组

注意

• in 在对 字典 操作时，判断的是 字典的键
• in 和 not in 被称为 成员运算符

1.3.8 语法总汇

1. 列表操作

分类	关键字 / 函数 / 方法	说明
增加	list.append(值)	在末尾追加值
	list.insert(索引,值)	在指定位置插入值, 超过索引会追加值
	list.extend(可迭代对象)	将可迭代对象 中 的元素 追加到列表(元组，列表)
删除	list.remove	删除指定值的 第一个匹配项
	del list[索引]	删除指定位置的值
	list.pop(索引)	删除指定索引的值, 并返回被删除的值
	list.clear()	清空列表
修改	list[值] = 新值	修改指定索引的值，索引不存在会报错
查询	list[索引]	根据索引取值，索引不存在会报错
	len(list)	列表长度(元素个数)
	if x in list	判断列表中是否包含某个值
	list.index(x)	根据值查询索引，返回 第一个匹配项 的索引，没有查到会报错
	list.count(x)	值在列表中出现的次数
排序	list.sort(reverse=False)	排序
	list.reverse()	逆序、反转

2. 元组操作

分类	关键字 / 函数 / 方法	说明
查询	tuple[索引]	根据索引取值，索引不存在会报错
	len(tuple)	元组长度(元素个数)
	if x in tuple	判断元组中是否包含某个值
	tuple.index(值)	根据值查询索引，返回 第一个匹配项 的索引，没有查到会报错
	tuple.count(值)	值在元组中出现的次数

3. 字典操作

分类	关键字 / 函数 / 方法	说明
增加	dict[key] = 值	键不存在，会添加键值对
删除	dict.pop(key)	根据键删除键值对,返回被删除的值
	del dict[key]	根据键删除键值对
	dict.clear()	清空字典
修改	dict[key] = value	键存在，会修改键值对的值
	dict.update({key: value})	取出字典2的键值对对字典1操作，键值对不存在，添加键值对；存在则修改值
	dict.setdefault(key, default=None)	键值对不存在，则添加键值对，值为默认值；存在则不做处理
查询	dict[key]	根据键取值，键值对不存在会报错
	dict.get(key, default=None)	根据键取值，键值对不存在返回默认值, 不会报错
	for key in dict	遍历字典, 获取所有的键
	for key in dict.keys()	遍历字典, 获取所有的键
	for key in dict.values()	遍历字典, 获取所有的值
	for key, value in dict.items()	遍历字典, 获取所有的键值对 (键, 值)

4. 字符串操作

分类	关键字 / 函数 / 方法	说明
分割	String.splict(分隔符)	以分割符拆分字符串, 返回列表
	String.partition(分隔符)	返回元组，把字符串分成一个 3 元素的元组 (分割符前面, 分割符, 分割符后面)
拼接	string1 + string2	拼接两个字符串
	String.join(list)	以字符串来连接字符串列表中每个元素，合并为一个新的字符串
替换	String.replace(旧内容，新内容，替换次数)	返回一个替换了原内容的新字符串，可以指定替换次数，默认全部
查询	string.find(目标字符串,开始索引，结束索引)	在指定范围内, 查询目标字符串的索引, 不存在返回-1
	string.rfind(目标字符串,开始索引，结束索引)	在指定范围内, 查询目标字符串的索引, 不存在返回-1, 从结尾处开始查找
	string.index(目标字符串,开始索引，结束索引)	在指定范围内, 查询目标字符串的索引, 不存在会报错
判断	String.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True
	String.isdecimal()	如果 string 只包含数字则返回 True
	string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True
	string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True
	string.startswith(目标字符串)	检查字符串是否是以 目标字符串 开头，是则返回 True
	string.endswith(目标字符串)	检查字符串是否是以 目标字符串 结尾，是则返回 True
大小写转换	string.lower()	返回新字符串，转换 字符串 中所有大写字符为小写
	string.upper()	返回新字符串，转换 字符串 中所有大写字符为大写
文本对齐	string.center()	按照指定宽度返回新字符串，并基于原字符串居中，可设置两端空白位置的填充字符
	string.ljust()	按照指定宽度返回新字符串，并基于原字符串左对齐，可设置两端空白位置的填充字符
	string.rjust()	按照指定宽度返回新字符串，并基于原字符串右对齐，可设置两端空白位置的填充字符
去除两端字符	string.strip(目标字符串)	返回新字符串，去除 字符串 左右两边的目标字符串, 不设置目标字符串则去除空格
	string.lstrip(目标字符串)	返回新字符串，去除 字符串 左边的目标字符串, 不设置目标字符串则去除空格
	string.rstrip(目标字符串)	返回新字符串，去除 字符串 右边的目标字符串, 不设置目标字符串则去除空格