容器类型

一、字符串

1、字符串介绍

如下定义的变量a，存储的是数字类型的值

a = 100

如下定义的变量b，存储的是字符串类型的值

b = "www.tulingxueyuan.com"
# 或者
b = 'www.tulingxueyuan.com'

总结:双引号或者单引号中的数据，就是字符串

字符串下标:就是标记空间的一个数字,也称为索引
特点:

• 每个字符单独存储，各占一个存储空间
• 为了方便标记处哪个空间存放的是哪个字符，Python使用了"下标"
• 如果从左侧开始编号，那么下标从 0 开始
• 如果从右侧开始编号，那么下标从-1开始
• 如果字符串只有3个字符例如"abc"，那么能用的下标为0、1、2不能使用超过2以上的，这种情况就是"越界"很危险会导致程序崩溃

name = 'abcdef'
print(name[0])
print(name[1])
print(name[2])

运行结果:
    a
    b
    c

2、字符串切片

1、概念:片是指对操作的对象截取其中一部分的操作
2、语法:[起始:结束:步长]
3、特点:

• 选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔
• 默认“步长”为1，即取完一个下标的数据之后，第二个下标的是在刚刚下标基础上+1
• 步长为正数，表示从左向右取数据
• 步长为负数，表示从右向左取数据
  4、代码示例:

name = 'abcdef'
print(name[0:3])  # 取下标为0、1、2的字符，注意取不到下标为3的空间
结果:abc


name = 'abcdef'
print(name[:3])  # 取下标为0、1、2的字符，注意取不到下标为3的空间,如果第一个参数没写则默认为0开始
结果:abc

name = 'abcdef'
print(name[3:5])  # 取下标为3、4 的字符
结果:de

name = 'abcdef'
print(name[2:])  # 取下标为2开始到最后的字符
结果:cdef

name = 'abcdef'
print(name[1:-1])  # 取 下标为1开始到右侧最后一个字符之前的所有字符
结果:bcdef

name = 'abcdef'
print(name[1:5:2])
步长为2表示间隔1个值取一次
结果:bd

name = 'abcdef'
print(name[5:1:-1])
5: 起始位置
1: 结束位置 （不包含）
-1: 步长，表示从右往左取值
结果:fedc

name = 'abcdef'
print(name[5:1:-2])
5: 起始位置
1: 结束位置 （不包含）
-2: 步长，表示从右往左取值并间隔一个值
结果:fd

name = 'abcdef'
print(name[::])
结果:abcdef
开始位置、结束位置都未指定，且步长也未指定那么步长用默认的1，则此时从最左取到最右

name = 'abcdef'
print(name[::-1])
结果:fedcba
开始位置、结束位置都未指定，步长为-1，此时从最右取到最左

name = 'abcdef'
print(name[::-2])
结果:fdb

4、总结:

• 切片使用规则中，要么一个冒号[开始位置:结束位置]，要么两个冒号[开始位置:结束位置:步长]
• 不写步长时，默认为1
• 步长为正数，表示从左向右取数据
• 步长为负数，表示从右向左取数据
• 当开始位置、结束位置都没有设定时，要看步长，如果步长为正数此时开始位置理解为最左，结束位置为最右，如果步长为负数此时开始位置理解为最右，结束位置为最左。

3、字符串常见操作

#find(): 检测str是否包含在 my_str中，如果是返回开始的索引值，否则返回-1
my_str = " welcome to www.tulingxueyuan.com"
print(my_str.find("to"))

#rfind():类似于find()函数，不过是从右边开始查找，返回的索引是从左边开始
print(my_str.rfind("to"))

# count:返回str在start和end之间在 my_str里面出现的次数
print(my_str.count("w"))

# replace:把 my_str 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次
print(my_str.replace("w", "x", 1))

#split 方法:以 str 为分隔符切片 my_str，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串
print(my_str.split(" " , 1))

# startswith:检查字符串是否是以 指定的字符串 开头, 是则返回 True，否则返回 False
print(my_str.startswith("welcome"))

# endswith:检查字符串是否以指定字符串结束，如果是返回True,否则返回 False
print(my_str.endswith("com"))

# lower:转换 my_str 中所有大写字符为小写
print(my_str.lower())

# upper 方法:转换 my_str 中所有小写字母为大写
print(my_str.upper())

# strip 方法:删除字符串两端的空白字符
print(my_str.strip())

# partition 方法:把my_str以str分割成三部分,str前，str和str后
print(my_str.partition("to"))

# splitlines 方法:按照行分隔，返回一个包含各行作为元素的列表
str = """welcome to www.tulingxueyuan.com
     thank you
     good good study day day up
    """
print(str.splitlines())

# isalpha:如果 my_str 所有字符都是字母 则返回 True,否则返回 False
str1="asd"
print(str1.isalpha())

# isdigit:如果 my_str 只包含数字则返回 True 否则返回 False
str2="123"
print(str2.isdigit())

# isalnum 方法:如果 my_str 所有字符都是字母或数字则返回 True,否则返回 False
print(str2.isalnum())

# join 方法:my_str 中每个元素后面插入str,构造出一个新的字符串
print(str1.join(str2))

返回结果:
'''
9
9
4
 xelcome to www.tulingxueyuan.com
['', 'welcome to www.tulingxueyuan.com']
False
True
 welcome to www.tulingxueyuan.com
 WELCOME TO WWW.TULINGXUEYUAN.COM
welcome to www.tulingxueyuan.com
(' welcome ', 'to', ' www.tulingxueyuan.com')
['welcome to www.tulingxueyuan.com', '     thank you', '     good good study day day up', '    ']
True
True
True
1asd2asd3
'''

二、列表

1、列表介绍及基本使用

1.定义方式:stu_names = [‘张三’, ‘李四’, ‘王五’]
2.基本使用:通过下标可以实现定位，然后就可以用这个数据(下标从0开始)

stu_names = ['张三', '李四', '王五']
print(stu_names[0])  # 此时只输出张三
stu_names[0] = "刘大胆"
print(stu_names[0])  

3.列表切片

stu_names = ['张三', '李四', '王五']
print(stu_names[1:3])
# 逆序
print(stu_names[::-1])

4.列表遍历

(1)for循环遍历
for stu_name in stu_names:
    print(stu_name)
(2)while循环遍历
i=0;
while(i<len(stu_names)):
    print(stu_names[i])
    i+=1

5.Python列表特点
列表可以存储不同类似的数据，而数组只能存储相同数据类型
teacher = [“刘大胆”, “湖南省长沙市”, 18, 176.5] # 18为年龄，176.5为身高

2、列表相关操作

# 数据增加
# 1.通过append可以向列表添加元素
    stu_names.append("张六")
    print(stu_names)
# 2.通过extend可以将另一个列表中的元素逐一添加到列表中
    str1 = ["留偶记","爱哦啥都"]
    stu_names.extend(str1)
    print(stu_names) #返回结果['刘大胆', '李四', '王五', '张六', '留偶记', '爱哦啥都']
# 3.insert(index, object)在指定位置index（索引，理解为下标即可）前插入元素object
    stu_names.insert(2,"刘大大")
    print(stu_names) #['刘大胆', '李四', '刘大大', '王五', '张六', '留偶记', '爱哦啥都']

#修改数据
    stu_names[2]="超级刘大胆"
    print(stu_names)

#数据查找:
# 1.in（存在），如果存在那么结果为true，否则为false
     find_name = input('请输入要查找的姓名:') # 获取用户要查找的名字
     # 查找是否存在
     if find_name in stu_names:
        print('找到了名字')
    else:
        print('没有找到')

# 2.count查询元素个数
    nums = [1,2,3,4,5,6,7,8,9,10]
    print(nums.count(1))

#数据删除
# 1.del：根据下标进行删除
    del nums[0]
    print(nums) #[2, 3, 4, 5, 6, 7, 8, 9, 10]
# 2.pop：删除最后一个元素
    nums.pop()
    print(nums) #[2, 3, 4, 5, 6, 7, 8, 9]
# 3.remove：根据元素的值进行删除
    nums.remove(2)
    print(nums) #[3, 4, 5, 6, 7, 8, 9]

#数据排序
# 1.sort方法是将列表按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。
    a = [1, 4, 2, 3]
    a.sort()
    print(a)  #[1, 2, 3, 4]
    a.sort(reverse=True)
    print(a)  #[4, 3, 2, 1]
# 2.reverse方法是将列表倒叙
    a.reverse()
    print(a) #[1, 2, 3, 4]

3、列表嵌套

应用:一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配

import  random
offices = [[],[],[]]
names = ['A', 'B', 'C', 'D', 'E', 'F','G','H']
for name in names:
    random_num = random.randint(0,2)
    offices[random_num].append(name)

i=1
for office_names  in offices:
    print('办公室%d的人数为:%d' % (i, len(office_names)))
    i += 1
    for name in office_names:
        print("%s" % name, end=' ')
    print("\n")
    print("-" * 20)

三、元组

1.元组是存储多个数据的一种方式
2.元组与列表类似，不同之处在于元组的元素不能修改
3.元组使用小括号()，列表使用方括号[]
4.元组的使用:

aTuple = ('a', 'b', 'c',1)
print(aTuple) #('a', 'b', 'c', 1)

5.可变对象：list(列表)、dict(字典)、set(集合)
不可变对象：tuple(元组)、string(字符串)、int(整数)、float(浮点数)、bool(布尔值)
6.元组的作用:可以防止数据被篡改

四、集合

集合是一种能够存储多个数据的方式
它最大的特点是：数据不能重复
也就是说

• 列表可以存储多个数据，支持增删改查
• 元组可以存储多个数据，不能修改
• 集合依然可以存储多个数据，数据不能重复

1.集合的使用

nums = {100,200,300}
print(type(nums))
for num in nums:
    print(num)
输出结果:
  <class 'set'>
  200
  100
  300

2.集合的遍历(数据去重)

nums1={1,2,3,4,5,5,5,5}
for num in nums1:
    print(num)
输出结果:
  1
  2
  3
  4
  5

3.集合无序性

num2 = {'a','b','c','d','e','f','g','h'}
print(num2)
输出结果:{'a', 'c', 'e', 'g', 'b', 'h', 'd', 'f'}

4.集合内置方法

add() 为集合添加元素
clear() 移除集合中的所有元素
copy() 拷贝一个集合
difference() 返回多个集合的差集
difference_update() 移除集合中的元素，该元素在指定的集合也存在。
discard() 删除集合中指定的元素
intersection() 返回集合的交集
intersection_update() 返回集合的交集。
isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset() 判断指定集合是否为该方法参数集合的子集。
issuperset() 判断该方法的参数集合是否为指定集合的子集
pop() 随机移除元素
remove() 移除指定元素
symmetric_difference() 返回两个集合中不重复的元素集合。
symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union() 返回两个集合的并集
update() 给集合添加元素

5.集合交并差运算代码示例

intersection = set1 & set2
print("交集:", intersection)  # 输出: {4, 5}

# 两个集合的并集运算
union = set1 | set2
print("并集:", union)  # 输出: {1, 2, 3, 4, 5, 6, 7, 8}

# 两个集合的差集运算
difference = set1 - set2
difference2 = set2 - set1
print("差集:", difference,difference2)  # 输出: {1, 2, 3}

# 对称差集运算（两个集合的差集的并集）
symmetric_difference = set1 ^ set2
print("对称差集:", symmetric_difference)  # 输出: {1, 2, 3, 6, 7, 8}

输出结果:
  交集: {4, 5}
  并集: {1, 2, 3, 4, 5, 6, 7, 8}
  差集: {1, 2, 3} {8, 6, 7}
  对称差集: {1, 2, 3, 6, 7, 8}

五、容器类型的类型转换

容器类型的类型转换不会包括字典

nums1 = [11, 22, 33]  # 定义列表
nums2 = (44, 55, 66)  # 定义元组
nums3 = {77, 88, 99}  # 定义集合

# 列表转换为元组、集合
print("-----------")
nums1_tuple = tuple(nums1)
print(type(nums1_tuple))
nums1_set = set(nums1)
print(type(nums1_set))

# 元组转换为列表、集合
print("-----------")
nums2_list = list(nums2)
print(type(nums2_list))
nums2_set = set(nums2)
print(type(nums2_set))

# 集合转换为列表、元组
print("-----------")
nums3_list = list(nums3)
print(type(nums3_list))
nums3_tuple = tuple(nums3)
print(type(nums3_tuple))

快速去重 使用set对list和tuple进行去重

nums1 = [11, 22, 44, 33, 22, 11, 55, 666, 44, 33, 22]
nums2 = (11, 22, 44, 33, 22, 11, 55, 666, 44, 33, 22)

print(set(nums1))  # 将nums1转换为集合的时候，就自动去重了
print(set(nums2))  # 将nums2转换为集合的时候，就自动去重了

六、字典

1、字典介绍

1.字典格式:{key: value, key2: value …}
2.说明:

• key可以理解为：我们自己可以定义的下标
• value可以理解为：我们要存储的真正的数据
• 字典只要存储一个数据，就必须用key: value（我们常称为键值对）组成
  3.代码示例:

student = {"name": "John", "age": 25, "city": "New York"}
print(student)
1.#通过keys()访问键
for key in student.keys():
    print(key)
#等价于 for key in student() 都能够获得键
2.#通过values()访问值
for value in student.values():
    print(value)
3.#通过items()访问元素
for item in student.items():
    print(item)

# 返回结果:
    {'name': 'John', 'age': 25, 'city': 'New York'}
    name
    age
    city
    John
    25
    New York
    ('name', 'John')
    ('age', 25)
    ('city', 'New York')

2、字典常见操作

(1)数据查询

# 普通方式
print(student['name']) #John
# get方式 不会导致报错
print(student.get('name1','当前字典不存在该键值对'))

(2)数据修改

name1 = input("请输入新的名称:")
student['name'] = name1  #如果是字符串则直接赋值 如果是数字则需要转型 即 int(内容)
print("修改后的名称:%s"%student['name'])

(3)数据增加

student['id'] = '10010'
print(student) #{'name': '刘', 'age': 25, 'city': 'New York', 'id': '10010'}

(4)数据删除

# 1.删除指定的元素
del student['name']
print(student)

# 2.删除整个字典
del student
print(student)
# 3.clear 删除整个字典元素
student.clear()
print(student) #{}

七、推导式

1、推导式介绍

推导式：就是一种能够快速生成数据的方式

print([x for x in range(21) if x % 2 == 0])
# 等同于
result = []
for x in range(21):
    if x % 2 == 0:
        result.append(x)
print(result)  # 输出和列表推导式相同的结果 
result 等同于 x 存储的最终数据

2、推导式分类

推导式，根据最终要生成的数据，简单划分为

• 列表推导式
• 集合推导式
• 字典推导式
  注意：没有元组推导式，而是生成器

3、列表推导式

1.单次for循环
a = [x for x in range(4)]
print(a)
2.两次for循环
b = [(x,y) for x in range(4) for y in range(4)]
print(b)
[(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), 
(1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3)]
.....(还可以进行多次循环)

练习:
请写出一段 Python 代码实现分组：一个 list 里面的元素,比如[1,2,3,…100]变成[[1,2,3],[4,5,6]…]

a = [x for x in range(101)]
b = [a[x:x+3] for x in range(0,len(a),3)]
print(b)

a[x:x+3] 是列表切片操作
表示从索引 x 开始，取到索引 x+3 之前的元素（不包含 x+3）
例如：
当 x=0 时，a[0:3] 取 [0,1,2]
当 x=3 时，a[3:6] 取 [3,4,5]
...
当 x=99 时，a[99:102] 取 [99,100]（因为 a 只有 101 个元素，到 100 结束）

4、集合推导式

集合推导式中也可以用if等，与列表推导式在格式上很类似

ab = {x for x in range(10)}
print(ab)
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

5、字典推导式

(1)案例一

快速生成一个1~10内key为某个数此时value为平方的字典

xxx = {x:x ** 2 for x in range(1,11)}
print(xxx)

输出结果:{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}

(2)案例二

快速生成一个1~10内key可以1时value为2，key为2时value为3…依次类推的字典

tui ={x:(x+1) for x in range(1,11)}
print(tui)

(3)案例三

编写代码用推导式，实现如下效果（列表中嵌套字典）
[{1: 1},
{2: 4},
{3: 9},
{4: 16},
{5: 25},
{6: 36},
{7: 49},
{8: 64},
{9: 81},
{10: 100}]

qian =[ {x:x**2} for x in range(1,11)]
print(qian)
输出结果:[{1: 1}, {2: 4}, {3: 9}, {4: 16}, {5: 25}, {6: 36}, {7: 49}, {8: 64}, {9: 81}, {10: 100}]

八、拆包

1、拆包介绍

拆包：是一种快速提取数据的方式
以元组为例

正常方式:
 nums = (11, 22, 33, 44)  # 定义一个元组
 num1 = nums[0]  # 通过下标来提取
 num2 = nums[1]  # 通过下标来提取
 num3 = nums[2]  # 通过下标来提取
 num4 = nums[3]  # 通过下标来提取
拆包方式:
 num1, num2, num3, num4 = (11, 22, 33, 44)
 print(num1, num2, num3, num4)

2、拆包方式

(1)列表拆包

a, b = [11, 22]
print(a) 11
print(b) 22

(2)元组拆包

a, b = (11, 22)
print(a) 11 
print(b) 22

(3)集合拆包

a, b = {11, 22}
print(a)
print(b)

(4)字典拆包

a, b = {"name": "顾安", "age": 18}
print(a) name
print(b) age

常见用法
student = {"name":"刘大胆","age":18}
for key1, value in student.items():
    print("姓名为:%s,年龄为%s"%(key1,value))  #%s 是字符串格式化符，它的特殊之处在于可以兼容任何数据类型
输出结果:
姓名为:name,年龄为刘大胆
姓名为:age,年龄为18

3.通过拆包交换变量

a = 4
b = 5
print("交换之前a=%d, b=%d" % (a, b)) a=4,b=5

a, b = b, a
print("交换之后a=%d, b=%d" % (a, b)) a=5,b=4

巧妙解法
a = 4
b = 5
print("交换之前a=%d, b=%d" % (a, b))

# 巧妙之处（没有用额外的变量）
a = a+b  9 = 4+ 5
b = a-b  b = 9 - 5  即4
a = a-b  a = 9 - 4  即5 
print("交换之后a=%d, b=%d" % (a, b))