Python基础（三）

Python基础（三）

1、序列类型

1.1、序列

序列指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。

1.2、序列类型

在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持以下几种通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

1.3、序列索引

序列中，每个元素都有属于自己的编号（索引）。

1. 正索引

从第一个起始元素开始，索引值从左向右，从 0 开始递增

2. 负索引

从第最后一个起始元素开始，索引值从右向左，从 -1 开始递减

1.4、序列切片

切片操作是截取序列元素部分数据的一种方法，它可以访问一定范围内的元素，通过切片操作，可以生成一个新的序列。

1. 语法格式

序列名[起始下标 : 结束下标 : 步长]

切片时包含起始下标元素，不包含结束下标元素。

步长默认为1。

2、字符串

2.1、字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号 ( ’ 或 " ) 来创建字符串。字符串中也有下标，可以通过下标取出对应的字符。

str = 'PYTHON'
print(str[0])#P
print(str[1])#Y

2.2、常用方法

1. 大小写转换

name = 'zhang san'
# 首字母大写
print(name.capitalize())  # Zhang san
estr = 'hello Python'
# 字符串全转换小写
print(estr.lower())  # hello python
# 字符串全转换大写
print(estr.upper())  # HELLO PYTHON

2. 格式化

a = ' hello  '
# 去除字符串中前后空格
print(a.strip())  # hello
# 去除字符串中前空格
print(a.lstrip())  # hello
# 去除字符串中后空格
print(a.rstrip())  # hello

3. 查询

str = 'hello word'
# 查找字符是否存在 找到返回第一次出现的下标，找不到返回-1
print(str.find('w'))  # 6
print(str.index('w'))  # 6 找不到会报错

swstr = 'hello python'
# 查看以XX开头/结尾 符合返回True，不符合返回False
print(swstr.startswith('h'))  # True
print(swstr.endswith('on'))  # True

4. 切片

# 切片 (左闭右开)
msg = 'hello Python'
b = msg[2:7]
print(b) #llo P
c = msg[2:]
print(c) #llo Python 到最后
d = msg[:2]
print(d) #he 从头
e = msg[::-1]
print(e) #nohtyP olleh 倒序

3、列表

3.1、list

是python中非常重要的数据结构，是一种有序的数据集合。

• 支持增删改查
• 列表中数据项可以变化，内存地址不会发生改变
• 用[]表示列表类型，数据想之间使用逗号进行分割
• 数据项类型没有限制
• 支持索引与切片操作

1. 例子

a = [1,2,3]
# len函数可以获取到列表对象中的数据个数
print(len(a))
print(type(a))

3.2、常用方法

1. 输出

li = ['ac', 1, 6.6, True]
# 输出
print(li)  # ['ac', 1, 6.6, True]
print(li[0])  # ac

2. 切片

li = ['ac', 1, 6.6, True]
# 切片
print(li[1:3])  # [1, 6.6]
print(li[2:])  # [6.6, True]
print(li[::-1])  # [True, 6.6, 1, 'ac']

3. 相乘

li = ['ac', 1, 6.6, True]
# 相乘
print(li * 2)  # ['ac', 1, 6.6, True, 'ac', 1, 6.6, True]

4. 查找

li = ['ac', 1, 6.6, True]
# 查找指定值的元素下标，找不到则报错
print(li.index(6.6))  # 2

5. 添加

li = ['ac', 1, 6.6, True]
# 追加
print(li)  # ['ac', 1, 6.6, True]
li.append(['新增', '列表'])
print(li)  # ['ac', 1, 6.6, True, ['新增', '列表']]

# 插入
lia = ['ac', 1, 6.6, True]
# 列表.insert(插入位置下标,插入数据)
lia.insert(1, '插入')
print(lia)  # ['ac', '插入', 1, 6.6, True]

# 扩展
lia = ['ac', 1, 6.6, True]
lib = ['bb', 123, False]
lia.extend(lib)
print(lia)  # ['ac', 1, 6.6, True, 'bb', 123, False]

6. 修改

# 修改
lia = ['ac', 1, 6.6, True]
lia[0] = 6
print(lia)  # [6, 1, 6.6, True]

7.删除

# 删除
lia = ['ac', 1, 6.6, True]
del lia[0]
print(lia)  # [1, 6.6, True]

# 批量删除
lia = ['ac', 1, 6.6, True]
del lia[1:3]
print(lia)  # ['ac', True]

# 删除指定数值的元素
lia = ['ac', 1, 6.6, True]
lia.remove(1)
print(lia)  # ['ac', 6.6, True]

# 删除指定索引的元素
lia = ['ac', 1, 6.6, True]
lia.pop(2)
print(lia)  # ['ac', 1, True]

4、元组

4.1、tuple

元组（tuple）是 Python 中另一个重要的序列结构，和列表类似，元组也是由一系列按特定顺序排序的元素组成。

元组特点：

• 创建后不可变。
• 用()创建，数据项用逗号分隔。
• 数据项可以是任何类型。
• 当元组只有一个元素是，后面要加上逗号，否则解释器会把该元组当作整形进行处理。

元组和列表（list）的不同之处在于：

• 列表的元素是可以更改的，包括修改元素值，删除和插入元素。
• 元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。
• 列表是用[]进行创建，元组是用()进行创建。

例子：

tupa = ('ab', 12, 6.66, [11, 22, 33])
print(type(tupa))
print(tupa) # ('ab', 12, 6.66, [11, 22, 33])
print(tupa[1]) # 12

4.2、常用方法

1. 遍历

tupa = ('ab', 12, 6.66, [11, 22, 33])
# 遍历
for item in tupa:
    print(item, end=" ")  # ab 12 6.66 [11, 22, 33]
    pass

2. 切片

tupa = ('ab', 12, 6.66, [11, 22, 33])
# 切片
print(tupa[1:3])  # (12, 6.66)
print(tupa[::-1])  # ([11, 22, 33], 6.66, 12, 'ab')
print(tupa[-1:-3:-1])  # ([11, 22, 33], 6.66)

3. 统计元素

tupa = ('ab', 12, 6.66, [11, 22, 33], 12)
# 统计元素在元组出现的次数
print(tupa.count(12))  # 2

4. 查找元素

tupa = ('ab', 12, 6.66, [11, 22, 33], 12)
# 统计元素在元组出现的首次下标索引
print(tupa.index(12))  # 1

5、字典

5.1、dict

字典（dict）是一种无序的、可变的序列，它的元素以“键值对{key:value}”的形式存储的集合。

字典特点：

• 字典中查找某个元素是，是根据键进行查找的。
• 支持对数据的添加，修改，删除操作。
• 字典中键不能重复，值可以重复，如果键重复会进行覆盖。
• 字典中每个键值对的键是不可变的，只能使用数字、字符串或者元组，不能使用列表，值可以是任意类型。
• 字典是可变的，并且可以任意嵌套。

例子：

a = {'one': 1, 'two': 2, 'three': 3}
print(type(a))
print(a)  # {'one': 1, 'two': 2, 'three': 3}

5.2、常用方法

1. 遍历

a = {'name': '张三', 'school': '666'}
# 遍历所有数据项
for iteam in a.items():
    print(iteam)
    pass
# 遍历所有键值对 ，区分key与value
for key, value in a.items():
    print('%s===%s' % (key, value))
    pass

2. 取值

a = {'name': '张三', 'school': '666'}
# 数据项长度
print(len(a))  # 2
# 获取所有的键
a = {'name': '张三', 'school': '666'}
print(a.keys())  # dict_keys(['name', 'school'])

# 获取所有的值
a = {'name': '张三', 'school': '666'}
print(a.values())  # dict_values(['张三', '666'])

# 获取所有键值对
a = {'name': '张三', 'school': '666'}
print(a.items())  # dict_items([('name', '张三'), ('school', '666')])

3. 修改与添加

a = {'name': '张三', 'school': '666'}
print(a)  # {'name': '张三', 'school': '666'}
# 添加字典数据或修改
print(a)  # {'name': '张三', 'school': '666'}
a['name'] = '李四'
print(a)  # {'name': '李四', 'school': '666'}
a['class'] = 1
print(a)  # {'name': '张三', 'school': '666', 'class': 1}
# 方式二
a = {'name': '张三', 'school': '666'}
a.update({'name': '王五'})
print(a)  # {'name': '王五', 'school': '666'}
a.update({'age': 18})  
print(a) # {'name': '王五', 'school': '666', 'age': 18}

4. 删除

# 删除
a = {'name': '张三', 'school': '666'}
del a['name']
print(a)  # {'school': '666'}
# 方式二
a = {'name': '张三', 'school': '666'}
a.pop('school')
print(a)  # {'name': '张三'}

5. 查找

a = {'name': '张三', 'school': '666'}
# 查找 通过键获取值
print(a['name'])  # 张三

6. 排序

# 排序
a = {'name': '张三', 'school': '666','age':'18'}
# 按key
print(sorted(a.items(),key=lambda d:d[0])) # [('age', 18), ('name', '张三'), ('school', '666')]
# 按value 注意value的数据类型要保持一致
print(sorted(a.items(),key=lambda d:d[1])) # [('age', '18'), ('school', '666'), ('name', '张三')]

6、集合

6.1、set

Python 中的集合（set），和数学中的集合概念一样，用来保存不重复的元素，即集合中的元素都是唯一的，互不相同。

a = {'1','a'}
print(type(a)) #<class 'set'>
# 或
b = set(['a', 'b'])
print(type(b))

6.2、常用方法

1. 遍历

a = {1,'c',1,(1,2,3),'c'}
for ele in a:
    print(ele,end=' ')  # 1 (1, 2, 3) c 

2. 添加

a = {"apple", "banana", "cherry"}
a.add("orange")
print(a) # {'apple', 'cherry', 'banana', 'orange'}

3. 删除

a = {"apple", "banana", "cherry"}
a.remove("apple") # 没有该项会报错
print(a) # {'banana', 'cherry'}
# 方式二
a = {"apple", "banana", "cherry"}
a.discard("apple")
print(a) # {'banana', 'cherry'}

4. 更新

a = {1, 3, 5, 7, 8, 9}
b = {2, 4, 6, 7, 8, 9}
a.update(b)
print(a) # {1, 2, 3, 4, 5, 6, 7, 8, 9} 将b中独有的元素添加到a中

5. 清空

a = {"apple", "banana", "cherry"}
a.clear()
print(a)  # set()

6. 差集

a = {1, 3, 5, 7, 8, 9}
b = {2, 4, 6, 7, 8, 9}
print(a.difference(b)) # {1, 3, 5} 得到a中独有的元素 
# print(a-b) 相同

7. 交集

a = {1, 3, 5, 7, 8, 9}
b = {2, 4, 6, 7, 8, 9}
print(a.intersection(b)) # {8, 9, 7} 得到a，b中重复的元素
# print(a&b) 相同

8. 并集

a = {1, 3, 5, 7, 8, 9}
b = {2, 4, 6, 7, 8, 9}
print(a.union(b)) # {1, 2, 3, 4, 5, 6, 7, 8, 9}得到a，b中所有的元素会去重
# print(a|b) 相同

7 、共用方法

7.1、合并

适用于字符串，列表，元组

作用：合并两个对象

实例：

# 字符串
a = 'hello '
b = 'word'
c = a + b
print(c)  # hello word
# 元组
a = (1, 2)
b = ('a', 'b')
c = a + b
print(c)  # (1, 2, 'a', 'b')
# 列表
a = [1, 2]
b = ['a', 'b']
c = a + b
print(c)  # [1, 2, 'a', 'b']

7.2、复制

适用于字符串，列表，元组

作用：对象按自身指定次数进行加操作

实例：

# 字符串
a = 'hello '
c = a * 2
print(c)  # hello hello
# 元组
a = (1, 2)
c = a * 2
print(c)  # (1, 2, 1, 2)
# 列表
a = [1, 2]
c = a * 2
print(c)  # [1, 2, 1, 2]

7.3、判断元素是否存在

适用于字符串，列表，元组，字典

作用：判断指定元素是否存在于对象中

实例：

# in 结果是一个布尔值
# 字符串
a = 'hello '
c = 'e'in a
print(c)  # True
# 元组
a = (1, 2)
c = 2 in a
print(c)  # True
# 列表
a = [1, 2]
c = 3 in a
print(c)  # False
# 字典 判断的是键
a = {'name':"张三",'age':18}
c = 'age' in a
print(c)  # True

8、小结

• 字符串（重要）
• 列表（重要）
• 元组
• 字典（重要）
• 集合