公共的方法

• 运算符
• 公共方法
• 容器类型转换

1 运算符

注意：

+ 和 * 不支持字典，如果对两个字符串做 + 操作就是将两个字符串进行 拼接

运算符	描述	支持的容器类型
+	拼接	字符串、列表、元组
*	复制	字符串、列表、元组
in	元素是否存在	字符串、列表、元组、字典
not in	元素是否不存在	字符串、列表、元组、字典

1.1 + 运算符

+ 号会将其进行拼接

str1 = 'aa'
str2 = 'bb'

list1 = [1,2]
list2 = [10,20]

t1 = (1,2)
t2 = (10,20)

dict1 = {'name':'Python'}
dict2 = {'age':30}

# + 合并

# 字符串 + 实现拼接
str3 = str1 + str2
print(str3)

# 列表
list3 = list1 + list2
print(list3)

# 元组
t3 = t1 + t2
print(t3)

[09:49:51 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
aabb
[1, 2, 10, 20]
(1, 2, 10, 20)

如果字典通过 + 运算的话直接报错

dict1 = {'name':'Python'}
dict2 = {'age':30}

# * 复制
print(dict1 + dict2)

# 直接报错 dict 之间不能做 +
[09:52:38 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
Traceback (most recent call last):
  File "/root/py-demo/day-1/test.py", line 14, in <module>
    print(dict1 + dict2)
TypeError: unsupported operand type(s) for +: 'dict' and 'dict'

1.2 * 运算符

* 会将其进行复制

str1 = 'a'
list1 = ['hello']
t1 = ('world')

# * 复制
print(str1 * 5)     # 得到 5 个 a
print(list1 * 2)    # 得到 2 个 hello
print(t1 * 3)       # 得到 3 个 world

[10:09:29 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
aaaaa
['hello', 'hello']
worldworldworld

1.3 in 运算符

in 判断数据是否存在，存在返回 true，不存在则返回 false

str1 = 'abcd'
list1 = [10,20,30,40]
t1 = (1,2,3,4,5)
dict1 = {'name':'py','age':20}

# in 判断是否存在
print('23' in str1) # false
print('a' in str1)  # true

print(20 in list1)  # true
print(11 in list1)  # false

print(1 in t1)  # true
print(44 in t1) # false

# 针对字典的 key 做判断成立，如果 key 存在返回 true 否则返回 false
print('name' in dict1)    # true
print('age' in dict1) # true

# 如果针对字典的 value 做判断的话是不成立的直接 false
print('py' in dict1)  # false
print(20 in dict1)      # false

[10:19:26 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
False
True
True
False
True
False
True
True
False
False

1.4 not in 运算符

str1 = 'abcd'
list1 = [10,20,30,40]
t1 = (1,2,3,4,5)
dict1 = {'name':'py','age':20}

# not in 判断是否不存在，如果不存在返回 true、否则返回 false
print('ee' not in str1)     # true
print('a' not in str1)      # false

print(10 not in list1)      # false
print(100 not in list1)     # true

print(1 not in t1)          # false
print(55 not in t1)         # true

print('name' not in dict1)  # false
print('py' not in dict1)    # true

[10:50:05 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
True
False
False
True
False
True
False
True

2 公共方法

函数	描述
len()	计算容器中的元素个数
del 或 del()	删除
max()	返回容器中元素最大的值
min()	返回容器中元素最小的值
range(start,end,step)	生成从 start 到 end 的数字，步长为 step，供 for 循环使用
enumerate()	函数用于将一个可遍历的数据对象(如列表、元组或字符串)组成为一个索引序列，同时列出数据和数据下标，一般用于 for 循环中

2.1 len()

计算容器中的元素个数

str1 = 'abcd'
list1 = [10,20,30,40]
t1 = (1,2,3,4,5)
s1 = {1,2,3,4}
dict1 = {'name':'py','age':20}

# 对元组进行 len
print(len(t1))

# 对字典进行 len ，返回 2 因为 len 统计的是序列中的个数，而一个键值对就为一个序列
print(len(dict1))

# 对集合进行 len
print(len(s1))

[11:19:44 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
5
2
4

2.2 del()

del 可以通过 del() 和直接使用 del 的方法来实现使用

str1 = 'abcd'
list1 = [10,20,30,40]
t1 = (1,2,3,4,5)
s1 = {1,2,3,4}
dict1 = {'name':'py','age':20}

# 使用的两种方法： del 删除数据，或者 del (删除数据)

# 指定删除 list1[0] 的下标数据
del list1[0]
print(list1)

# 指定删除 dict1 key 为 name 的数据
del dict1['name']
print(dict1)

# 指定删除 str1
del(str1)
print(str1)

[11:56:26 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
[20, 30, 40]                # 下标为 0 的数据已经被删除、
{'age': 20}                   # name key 已经被删除
Traceback (most recent call last):
  File "/root/py-demo/day-1/test.py", line 15, in <module>
    print(str1)
NameError: name 'str1' is not defined # str1 已经被删除，提示没有找到

2.3 max() 和 min()

max：返回容器中元素最大的值

min：返回容器中元素最小的值

str1 = 'abcdef'
list1 = [1,2,3,4,5]

# 输出 list1 的最大和最小值
print(max(list1))
print(min(list1))

# 输出 str1 的最大和最小值
print(max(str1))
print(min(str1))

[12:02:12 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
5
1
f
a

2.4 range()

在使用 range 之前，我们需要先了解他的语法和作用

range(start,end,step)
# 可以看到 range 有三个参数分别是，start、end、step
# 所谓的开始结束步长需要我们填写整数

# 通过 range 1-10 的数字，并且步长为 1
# 输出 1 2 3 4 5 6 7 8 9 10
for i in range(1,10,1):
    print(i,end='')

print()

# 步长为 2
# 输出 1 3 5 7 9
for i in range(1,10,2):
    print(i,end='')

print()

# 如果不写 start 默认步长为 1，默认起始 0
# 输出 0 1 2 3 4 5 6 7 8 9
for i in range(10):
    print(i,end='')
print()

[13:49:32 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
123456789
13579
0123456789

注意：

• range() 生产的序列不包含 end 数字
• range() 如果不写 start 起始，默认为 0 开始计算
• range() 如果不写步长默认为 1 开始

2.5 enumerate()

enumerate()：该函数作用于一个可遍历数据对象，组合为一个索引序列，返回的结果是数据和数据所在的下标

语法：

enumerate(可遍历对象,start=0)

注意：

start 参数用来设置遍历数据的下标起始值，默认为 0

快速体验：

list1 = ['a','b','c','d','e']

# 将每个元素对应的下标输出
for i in enumerate(list1):
    print(i)

print()
# start=0 就是从下标为 0 的数据起始
for index,char in enumerate(list1,start=0):
    print(f'下标是{index},对应的字符是{char}')

print()
# start=1 ，也就是修改下标显示为 1
for index,char in enumerate(list1,start=1):
    print(f'下标是{index},对应的字符是{char}')

[14:19:36 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')

下标是0,对应的字符是a
下标是1,对应的字符是b
下标是2,对应的字符是c
下标是3,对应的字符是d
下标是4,对应的字符是e

下标是1,对应的字符是a
下标是2,对应的字符是b
下标是3,对应的字符是c
下标是4,对应的字符是d
下标是5,对应的字符是e

3 容器类型转换

3.1 tuple()

作用：将某个序列转换成元组

list1 = [10,20,30,40,50,60,21]
s1 = {100,200,300,400,500}

print(type(list1),type(s1))

# 将 list1 列表类型和 s1 集合类型转为元组类型
t = tuple(list1)

print(t,type(t))

ts = tuple(s1)
print(ts,type(ts))

[14:43:56 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
<class 'list'> <class 'set'>
(10, 20, 30, 40, 50, 60, 21) <class 'tuple'>
(100, 200, 300, 400, 500) <class 'tuple'>

3.2 list()

作用：将某个序列转成列表

list1 = [10,20,30,40,50,60,21]
s1 = {100,200,300,400,500}
t1 = ('a','b','c','d','e')

# 将集合转为 list
lists1 = list(s1)
print(lists1,type(list1))

# 将元组转为 list
listt1 = list(t1)
print(listt1,type(listt1))

[14:49:05 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
[100, 200, 300, 400, 500] <class 'list'>
['a', 'b', 'c', 'd', 'e'] <class 'list'>

3.3 set()

作用：将某个序列转为集合

list1 = [10,20,30,40,50,60,21]
s1 = {100,200,300,400,500}
t1 = ('a','b','c','d','e')

# 将 list 列表转为集合
slist = set(list1)
print(slist,type(slist))

# 将 tuple 元组转为集合
stuple = set(t1)
print(stuple,type(stuple))

[14:49:31 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
{40, 10, 50, 20, 21, 60, 30} <class 'set'>
{'c', 'a', 'b', 'e', 'd'} <class 'set'>