Python——数据操作_python 数据操作-优快云博客

i = ('abcde'
     'fghgjlk')
j = 'a'
k = ("wfewg"
     "wrger")
l = """wefwege
rdgerg"""
m = '''fewfwef
wefewf'''
print(f'i:{i},类型：{type(i)}')      #<class 'str'>
print(f'j:{j},类型：{type(j)}')      #<class 'str'>    python没有字符类型，只有字符串数据类型
print(f'k:{k},类型：{type(k)}')
print(f'l:{l},类型：{type(l)}')
print(f'm:{m},类型：{type(m)}')

print(f'获取字符串m的第二个字符：{m[1]}。和第三个字符:{m[2]}')

2.字符串切片：

是指对操作的对象截取其中一部分的操作。字符串，列表，元组都支持切片

(1).语法：

序列[开始位置下标:结束位置下标:步长]

(2.)注意：

1.不包含结束位置下标对应的数据，正负整数均可
2.步长是选取间隔，正负整数均可，默认步长为1，可不写.
3.如果不写开始下标，默认从0开始选取
4.如果不写结束下标，默认选取到最后
5.如果不写开始和结束下标，默认选取所有
6.如果步长为负数，表示倒序选取从右至左 <------
7.下标表示最后一个数据，从右往左依次-1，-2，-3....
8.如果选取方向（下标开始到结束的方向）和步长的方向冲突，则无法选取数据

(3).示例代码

c = 'changanyuexia'
print(c[7:10:1])      # 输出yue  7索引是y, 10索引是x 但切片不包含结束为止下标，即仅到e，步长指的是7-10这部分内选取的间隔，而不是截取的总长度
print(c[::-1])        # 倒序
print(c[-7:-10:-1])   # 倒序截取
print(c[-4:-1:-1])    # 选取方向与步长方向冲突，无法选取到数据

3.字符串的常用操作方法

查找，修改，判断三大类

(1).查找

3.1.1 find()

所谓字符串查找方法即是查找子串在字符串中的位置或出现的次数

find(): 检测某个子串是否包含在这个字符串中，存在即返回子串开始位置的下标，否则返回-1
语法：字符串序列.find(子串，查找范围的开始位置下标，查找范围的结束位置下标)
注意：开始位置和结束位置下标可以省略，表示在整个字符串序列中查找

3.1.2 rfind()

rfind(): 和find()功能相同，但查找方向为右侧开始

3.1.3 index()

index():检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则报异常
语法：

字符串序列.index(子串，开始位置，结束位置) # 开始位置结束位置可忽略不写

3.1.4 rindex()

rindex(): 和index()功能相同，但查找方向为右侧开始

3.1.5 count()

count(): 返回某个子串在字符串中出现的次数

3.1示例代码

str1 = 'chang an yue xia'
s = str1.find('an')     # 未指定范围，在整个序列查找到第一次出现的位置
rs = str1.rfind('an')
print(f's={s},rs={rs}')
s1 = str1.find("an",3)   # 指定范围从第二次出现开始查找，未指定结束范围，表示从开始位置查找到末尾
print(s1)
i = str1.count("an")
print(f'an出现次数{i}')

(2).修改

所谓修改字符串，指的就是通过函数的形式修改字符串中的数据
字符串是不可变数据类型

3.2.1 replace()

替换：原有字符串不会改变，会返回一个新字符串

语法：

字符串序列.replace(旧子串，新子串，替换次数)

注意：

1.替换次数如果查出子串出现多次，则替换次数为该子串出现的次数
2.替换次数如果超出了子串出现的次数，则表示替换所有的子串

3.2.2 split()

按照指定字符分割字符串返回值是一个序列

语法：

字符串序列.split(分割字符，num)

# num表示分割字符出现的次数，即将来返回数据个数为num+1个

3.2.3 join()

用一个字符或子串合并字符串，即将多个字符串合并为一个新字符串

语法：

字符或子串.join(多字符串组成的序列)

3.2.4 capitalize()

将字符串第一个字符转换成大写

注意：

capitalize()函数转换后，只字符串第一个字符大写，其他的字符全都小写

3.2.5 title()

将字符串每个单词首字母转换成大写

3.2.5 lower()

将字符串中的大写字母转小写

3.2.6 upper()

将字符串中的小写字母转换成大写

3.2.7 lstrip()

删除字符串左侧空白字符

3.2.8 rstrip()

删除字符串右侧空白字符

3.2.9 strip()

删除字符串两侧空白字符

3.2.10 ljust()

返回一个原字符串左对齐，并使用指定字符（默认空格）填充至对应长度的新字符串

语法：

字符串序列.ljust(长度，填充字符)

3.2.11 rjust()

返回一个原字符串右对齐，并使用指定字符（默认空格）填充至对应长度的新字符串
语法与ljust同

3.2.12 center():

返回一个原字符串居中对齐，并使用指定字符（默认空格）填充至对应长度的新字符串
语法与ljust同

示例代码

newstr1 = str1.replace('an','xx',1)
newstr2 = str1.replace('an','xx',2)
newstr3 = str1.replace('an','xx',3)
print(f'newstr1={newstr1},\nnewstr2={newstr2},\nnewstr3={newstr3}')

str1 = 'changanyuexia'
newstr1 = str1.split('n',2)
print(f'newstr1={newstr1}')

biglist = ['aa','bb','cc']
newbiglist1 = '...'.join(biglist)
newbiglist2 = '000'.join(biglist)
print(newbiglist1)
print(newbiglist2)

str1 = '   hell word I\'am changAn '
print(str1)
print(str1.capitalize())
print(str1.title())
print(str1.lower())
print(str1.upper())
print(str1.lstrip())
print(str1.ljust(100,'!'))
print(str1.rjust(100,'!'))
print(str1.center(100,'!'))

(3).判断

所谓判断就是判断真假，返回的结果是布尔型数据类型：True或False

3.3.1 startswith():

检查字符串是否是以指定的子串开头，是则返回True 否则False
如果设置了开始和结束下标，则在指定范围内检查

语法：

startswith(子串，开始位置下标，结束位置下标)

3.3.2 endswith():

检查字符串是否是以指定的子串结尾，是则返回True 否则False
如果设置了开始和结束下标，则在指定范围内检查

语法：

endswith(子串，开始位置下标，结束位置下标)

3.3.3 isalpha():

如果字符串至少有一个字符并且所有字符都是字母则返回True 否则False

3.3.4 isdigit():

如果字符串只包含数字则返回True 否则返回False

3.3.5 isalnum():

如果字符串至少有一个字符并且所有字符串都是字母或者数字，则返回True,否则返回False

3.3.6 isspace();

如果字符串中只包含空白，则返回True,否则返回False

二、列表

列表可以一次性存储多个数据，且可以是不同的数据类型

[数据1，数据2，数据3，数据4……]

一般尽量存储相同数据类型的数据---便于操作

注意：

列表是可变数据类型

下标与字符串同！

列表的常用操作：增删改查

判断数据是否存在：

in: 判断指定数据早某个列表序列，在则True

格式：数据 in 列表

not in: 判断指定数据不在某个列表，不在则返回True

1.查找数据：

index(数据，开始下标，结束下标): 返回指定数据所在位置的下标，后两个参数为查找范围不存在则报错

count(数据): 统计指定数据在当前列表中出现的次数

len(列表): 访问列表长度，即列表中数据的个数

2.增加数据：增加指定数据到列表中

append(): 列表结尾追加数据，如果数据是一个序列列表，则追加整个序列到列表（列表嵌套）
语法：列表.append(数据)

extend(): 列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表（还是一个列表）
语法：列表.extend(数据)

insert(): 指定位置新增数据    如果指定位置有数据了，则原来数据后移一位
语法：列表.insert(位置下标，数据)

3.删除数据：列表中删除数据

del 列表: 删除列表

例如： del namelist

pop(): 删除指定下标的数据（若不指定下标默认为删除最后一个数据），并返回该数据
语法：列表.pop(下标)

remove(): 移除列表中某个数据的第一个匹配项(如果有重复数据的话)
语法：列表.remove(数据)

clear(): 清空列表

4.修改数据：修改列表数据

直接用索引修改，例如：列表[索引] = '新值'

reverse(): 逆置     将列表中的数据逆序排列
语法：列表.reverse()

sort(): 排序
语法：列表.sort(key=None,reverse=False)
注意：

        reverse表示排序规则，reverse=True表示降序，reverse=False表示升序（默认）
        如果列表中有字典，排序要按照字典的某个key值排序，就需要用到key参数，否则无须

copy(): 复制序列列表   返回值是一个重复的列表
语法：列表_1 = 列表.copy()
场景：

        修改数据时一般备份数据，保留原始数据
        工作中删除数据时一般先复制备份

示例代码1

li = [1,2,3,4,5,6,7,8,'an']

print(li.index('an',0,9))
print(li.count(4))
print(len(li))

print(2 in li)
print('an' in li)
print('aaaa' in li)
print(2 not in li)
print('aaaa' not in li)

示例代码2


# 查找输入的名字是否存在   可用来判断输入的账号是否存在，存在则提示登录，不存在则提示创建
namelist = ['张三','李四','王五','李二','李星云','姬如雪','大帅']
name = input('输入查找的名字\n')
if name in namelist:
    print(f'名字存在，输入的是{name}')
else:
    print('输入的名字不存在')
'''
'''
# 创建账号
addresslist = ['123','456','789','147']
print(addresslist)
address = input('输入账号：\n')
while True:
    if address in addresslist:
        print('账号已经存在，请跳转登录')
        break
    else:
        newaddress = input('账号不存在，请先创建账号：')
        if newaddress not in addresslist:
            addresslist.append(newaddress)        #增加数据
            if newaddress in addresslist:
                print('账号创建成功')
                break
            else:
                print('账号创建失败，返回首页！')
        elif newaddress in addresslist:
            print('账号已经存在，请跳转登录')
            break
print(addresslist)

示例代码3

nlist = ['123','456','789','147']
print(nlist)
nlist.insert(0,'新增')
print(nlist)
dele =  nlist.pop(0)
print(f'{nlist},删除了:{dele}')

nlist.insert(0,'123')
print(nlist)
nlist.remove('123')
print(nlist)
nlist.clear()
print(nlist)

a = [1,3,6,9,2,4,7,8,3,67,8]
print(a)
a.sort()   # 默认False升序
print(a)
a.sort(reverse=True)  # 修改为降序True
print(a)

copya = a.copy()
print(a)
print(copya)

列表的循环遍历

while i < len(list):
      print(list[i])
      i+=1

for i in list:
      print(i)

示例代码

a = [1,2,3,5,76,9,0,6,4,2,4,65,8,9,54,342,5,5,7,4,342,]

# while循环遍历列表
i=0
while i < len(a):
    print(a[i],end=" ")
    i+=1
print()
# for循环遍历列表
i=0
for i in a:
    print(i,end=" ")

列表嵌套

列表嵌套：就是一个大列表中装了若干小列表，列表之间又互相嵌套

如何查找嵌套列表里面的深层列表

例如： a = [1,[1.2.3,[4.5.6]],7,8,9] 查找6

1.先找到列表里面最外层列表对应的索引值 a[1]
2.再查找里层列表的索引值 a[1][3]
3.以此类推。。。。。。a[1][3][2]

示例代码：

a = [1, [1,2,3, [4,5,6]], 7, 8, 9]
print(a[1][3][2])   # 6

#  将8位老师随机分配到三个办公室内
teachers = ['A','B','C','D','E','F','G','H']   # 表示8位老师
offices = [[],[],[]]    # 表示三个办公室
for teacher in teachers:
    ran = random.randint(0,2)   # 范围0-2 即0,1,2
    offices[ran].append(teacher)
print(offices)
# 分别打印每一个办公室
for office in offices:
    print(f'{office},办公室人数{len(office)},老师分别是:')
    for teacher in office:
        print(teacher)

三、元组

元组：元组可以一次性存储多个数据，但元组内的数据是不能更改的

组----不可变数据类型元

元组用（）创建,并用逗号隔开各个数据，数据可以是不同数据类型

例如：

a = (1,'ada',3.1,) 创建一个元组a

多个数据元组: t1 = (10,20,30)
单个数据元组: t2 = (10,)

1.注意：

如果定义的元组只有一个数据，那么这个数据后面也必须添加逗号，否则数据类型为唯一的

示例代码

a = []
print(type(a))   # <class 'list'>
b = ()
print(type(b))   # <class 'tuple'>
t1 = (10)
print(type(t1))  # <class 'int'>
t2 = (10,)
print(type(t2))   # <class 'tuple'>
t3 = ("abc")
print(type(t3))   # <class 'str'>
t4 = ("abc",)
print(type(t4))   # <class 'tuple'>

2.元组的常见操作：

元组不支持修改数据（不可变型），仅支持查找数据（按下标查找）

index(元素): 查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表，字符串的index()方法相同

count(元素): 统计某个数据在当前元组出现的次数

len(列表): 返回列表中数据的个数，即列表长度

2.1注意：

元组内的直接数据，如果修改则立即报错
但是如果元组内有列表，修改列表里面的数据则是支持的
故若元组中需要放入可修改数据，可在元组内加入列表

2.2合并元组

另类的元组添加数据方式 ----用加号将两个元组连接起来

a1 = (10,20,30,40)
b1 = (50,60,70,80,90)
c = a1 + b1
print(c)

2.3示例代码

a = (10,20,30,40,50,10,10)
print(a.index(20))
print(a.count(10))

b = (10,20,30,['A','B','C','D'],40,50)
print(b)
b[3][0]  = '修改'       # 修改元组内的列表第一个数据源
print(b)
print(f'b的长度为：{len(b)}')

# 合并元组-----另类的元组添加数据方式
a1 = (10,20,30,40)
b1 = (50,60,70,80,90)
c = a1 + b1
print(c)

四、字典

字典为可变类型

字典：字典里面的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不支持下标
后期无论数据如何变化，只需要按照对应的键的名字查找数据即可

1.字典特点：

1.符号为大括号
2.数据为键值对形式出现
3.一个字典可放多个键值对，各个键值对之间用逗号隔开

2.字典创建

2.1有数据字典创建方式

dict1 = {'name':'Tom','age':'20','gender':'男'}

2.2空字典创建

有两种创建方式：
1. dict2 = {}
2. dict3 = dict()

3.字典常见操作：

3.1增加

字典中新增数据

写法：

字典序列[key] = 值

注意：如果key存在则修改这个key对应的值，如果key不存在则新增此键值对

3.2删除

del() / del : 删除字典或删除字典中指定的键值对
clear(): 清空字典

3.3修改

写法：

字典序列[key] = 值（与增加数据相同）

注意：如果key存在则修改这个key对应的值，如果key不存在则新增此键值对

3.4查找

3.4.1 key值查找

如果当前查找的key值存在，则返回对应的值，否则报错
例如：print(dict1['name']) # 返回name对应的值

3.4.2 get():

语法：

字典序列.get(key,默认值)

注意：如果当前查找的key值不存在则返回第二个参数（默认值），如果省略第二个参数不写则返回None

3.4.3 keys():

返回可迭代对象（所有的键）

3.4.4 values():

返回可迭代对象（所有的值）

3.4.5 items():

查找字典中所有的键值对，返回可迭代对象，里面的数据是元组，元组[0]是key键，元组[1]是值

示例代码

# 创建有数据字典
dict1 = {'name':'Tom','age':'20','gender':'男'}
print(dict1)
print(type(dict1))    # <class 'dict'>

# 创建空字典
dict2 = {}
dict2_1 = dict()
print(f'{dict2},{type(dict2)}')      # {},<class 'dict'>
print(f'{dict2_1},{type(dict2_1)}')  # {},<class 'dict'>

dict1['name'] = 'Rose'   # 修改
print(dict1)
dict1['weight'] = '80'   # 添加
print(dict1)

# key值查找
print(dict1['name'])
# get():
c = dict1.get('id','找不到')
c1 = dict1.get('id')
print(c)
print(c1)

# keys()  values()  items
print(dict1.keys())
print(dict1.values())
print(dict1.items())




#遍历字典

for key in dict1.keys():  # 遍历字典的键
    print(key,end=" ")
print()
for value in dict1.values(): #  遍历字典的值
    print(value,end=" ")
print()
for item in dict1.items():  # 遍历字典的元素（键值对）
    print(item)

for key,value in dict1.items():    # 遍历字典的键值对并以指定格式显示
    print(f'{key}={value}')

五、集合

创建集合使用{}或者set()
但是如果要创建空集合只能用set()，因为{}表示用来创建空字典

字典与集合都是{}表示，但字典中存入的是键值对，集合中存入的是单个数据

集合------去重：集合中不能有重复的数据，如果需要去重就存入集合.

1.注意：

集合不支持下标！！！！！！集合中的数据是无序的

2.集合中常见的操作方法：

2.1增加数据：

add():

2.1.1 语法：

集合.add(数据)

集合有去重功能，所以当向集合中追加的数据是当前集合已有的数据时，则不会进行任何操作

update(): 追加的数据是序列[]

2.2删除数据：

remove(): 删除集合中的指定数据，如果数据不存在则报错

2.2.1语法：

集合.remove(数据)

discard(): 删除集合中的指定数据，如果数据不存在也不会报错

pop(): 随机删除某个数据，并返回删除的数据
语法：删除的数据 = 集合.pop()

2.3查找数据：

in: 判断数据在集合序列返回值是boolean
not in: 判断数据不在集合序列返回值是boolean

例如： print( 10 in s ) # 判断10是否在集合s中

2.4.示例代码

a = set()    # 创建空集合
print(type(a))      # <class 'set'>

a = set('aifuu')
print(a)

b = {10,20,30,40,50,60,10}   # 重复的数据无法存入，会自动丢弃一个重复的
print(b)                     # {40, 10, 50, 20, 60, 30}

p = b.pop()
print(b)
print(p)

print(10 in b)
print(10 not in b)

六、公共操作

1.公共运算符：

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

2.公共方法：

len():       计算容器中元素个数

del或del():   删除

max():      返回容器中元素的最大值

min():      返回容器中元素的最小值

range(start,end,step): 生成从start到end的数字，步长为step，供for循环使用
包头不包尾(生成的数字不包含end)

enumerate():   函数用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标，一般用于在for循环中

语法：

enumerate(可遍历对象，start=0)
注意：start参数用来设置遍历数据的下标的起始值，默认为0.
简单理解：就是将序列内元素添加一个编号即索引后将其返回成一个元组
元组第一个数据是原迭代对象的数据对应的下标
元组第二个数据是原迭代对象的数据

3.示例代码

str1 = 'a'
newstr = str1*5
print(newstr)

a = [10,20]
b = a*5
print(b)

c = (10,)
d = c*5
print(d)

# 批量复制符号
print('@'*10)

s = 'changanyuexia'
print('an' in s)

# range()实验
for r in range(10,20,1):
    print(r,end=" ")

print()
# max（）   min（） 实验
a = [1,2,3,5,8,9,3,5]
print(max(a))
print(min(a))

# enumerate()实验
j = [10,23,54,675,7,234,2,23,4,45,6]
for i in enumerate(j):
    print(i,end=" ")
print()
for index,i in enumerate(j,start=0):
    print(f'索引:{index},对应的值{i}')

y = {10, 20, 30, 40, 50, 60}
for i in enumerate(y, start=1):
    print(i, end=" ")

七、容器类型转换

1.容器类型转换

tuple():    作用:将某个序列转换成元组
list():     作用: 将某个序列转换成列表
set():      作用: 将某个序列转换成集合

2.推导式

2.1分类:

列表推导式
字典推导式
集合推导式

2.2.列表推导式

2.2.1作用:

用一个表达式创建一个有规律的列表或者控制一个有规律列表(化简代码)

列表推导式又叫列表生成式

2.2.2语法:

list1 = [i for i in range(10,20)] 此时第一个i为前面for循环的返回值

2.2.3示例代码

list1 = [i for i in range(10, 20)]
print(list1)


带if的列表推导式
需求: 创建0-10的偶数列表
    方法一: range()步长实现
          [ i for i in range(0,10,2)]
    方法二: if 实现
          [ i for i in range(10) if i%2 == 0]




多个for循环实现列表推导式
语法事例: list2 = [(i,j) for i in range(1,3) for j in range(0,3)]
此时相当于两个for循环嵌套。前面的i为第一个循环的返回值，j为第二个循环的返回值





list2 = [(i, j) for i in range(0, 3) for j in range(0, 3)]  # 第一个循环0,1,2。第二个循环0,1,2
print(list2)

2.3字典推导式:

2.3.1作用:

1.快速合并列表为字典或提取字典中目标数据
2.两个列表合并为一个字典
3.提取字典中目标数据

2.3.2区别

字典推导式的返回值中间的符号为冒号:。
列表推导式的返回值为等号=。

2.3.3两个列表合并为一个字典

2.3.3.1.注意:

1. 如果两个列表数据个数相同，len统计任何一个列表长度均可以
2. 如果两个列表数据个数不同，len统计数据个数多的列表则报错，len统计数据个数少的列表不会报错

2.3.3.2示例代码

dict1 = {i: i ** 2 for i in range(1, 5)}
print(dict1)

#  两个列表合并为一个字典
l1 = ['name', 'age', 'weight']
l2 = ['张三', '23', '80']
d = {l1[i]: l2[i] for i in range(len(l1))}
print(d)

# 提取字典中目标数据  提取value值大于等于350 的键值对
l3 = {'A': 100, 'B': 300, 'C': 800, 'D': 500, 'E': 200, 'F': 350}
d1 = {key: value for key, value in l3.items() if value >= 350}
print(d1)