Python数据类型以及基本操作

python的数据类型

python常见的数据类型可分为str(字符串),int(整数)，float(浮点数)，boolean(布尔值本质上也是数值类型)，list(列表)，dict(字段)，tuple(元组)，set(集合)

数据类型的操作

列表

删除操作

1. remove:根据元素名删除列表中的某个元素
2. del :根据下标删除元素
3. pop:根据下标删除元素，并且返回被删除的元素

添加值操作

1. list.append(元素值):在列表的末尾处添加元素
2. list.insert(索引,元素值):在指定的位置插入元素

列表的拼接

li1 = [1,2,3]
li2 = [4,5,6]
li3 = li1 + li2
print(li3)
# 打印结果:[1,2,3,4,5,6]

li1 = [1,2,3]
li2 = [4,5,6]
li1.extend(li2)
print(li1)
# 打印结果:[1,2,3,4,5,6]

排序

sort:

li1 = [1,3,2]
# 默认升序排序
li1.sort()
print(li1) # 打印结果:[1,2,3]

# 降序排序
li1 = [1,3,2]
# 使用降序排序，reverse=True,默认值为False
li1.sort(reverse=True)
print(li1) # 打印结果:[3,2,1]
# 区分大小写的排序
li2 = ['a','B','e','d']
li2.sort()
print(li2) # 打印结果['B','a','d','e']
# 不区分大小写的排序
li2 = ['a','B','e','d']
li2.sort(key=str.lower)
print(li2) # 打印结果：['a','B',‘d’,'e']

sorted函数
与list的sort方法的区别:

1. sort方法时改变了原有的列表，而sorted函数是返回一个新的列表，不改变原有的列表
2. sort方法与sorted函数都是用于排序，都可以升序或降序排列，可以区分或不区分字母大小写的排列

li1 = [2,1,3]
li2 = sorted(li1)
print(li2) # 打印结果:[1,2,3] 

切片

切片格式:列表名[start:end：step],start:起始索引(默认值为0)，end:结束索引，step:步长(默认值为1),可为正整数或负正整数,正数时正向取值，负数时负向取值
实例代码:

li1 = [1,2,3,4,5,6]
li2 = li1[0:3:1]
print(li2) # 打印结果:[1,2,3]
# 全部截取
li2 = li1[:]
print(li2) # 打印结果:[1,2,3,4,5,6] 
li2 = li1[::-1]
print(li2) # 打印结果:[6,5,4,3,2,1]

enumerate()函数可以实现同时输出索引和元素值。

li = [1,2,3,4,5,6]
for index,item in enumerate(li):
	print(index) # 0 1 2 3 4 5
	print(item)  # 1 2 3 4 5 6

其他操作

1. list.count(元素值)统计某个元素在列表中出现的次数。
2. list.index(元素值)获取某个元素在列表中首次出现的索引位置。
3. list.reverse()使列表翻转
4. len()获取列表(list),集合(set),字符串(str),字典的长度
5. sum(list)返回列表每一项元素的求和，前提是每一个元素都必须是数值型(int,float)
6. max()返回最大值
7. min()返回最小值

列表推导式

使用推导式可以快速生成一个列表,或者根据某个列表生成满足指定需求的列表。
列表推导式通常有以下几种常用的语法格式：

# 1.生成指定范围的数值列表,语法格式如下:
# list = [Expression for var in range]
# list:表示生成的列表名称
# Expression:表达式,用于计算新列表的元素;
# var 循环变量;
# range:采用range()函数生成的range对象。
li1 = [i for i in range(1,11)]
print(li1) # 打印结果
# 2. 根据列表生成指定需求的列表
li2 = [i*2 for i in li1]
print(li2) # 打印结果:[2,4,6,8,....]
# 3.从列表中选择符合条件的元素组成新的列表
li3 = [i for i in li1 if i%2 == 0]
print(li3)# 打印结果:[2,4,6,8,10]

dict(字典)

字典常见的几种创建方式

# 方式1：
dic = {'k':'v'}
#方式2：
dic = dict(('k','v'))
# 方式3：
dic = dict(one:1,two:2,three:3)
# 方式4：
dic = dict({'k','v'})
#方式5:
dic = dict(zip(['one','two','three'],[1,2,3]))
# 方式6 字典推导式:
dic = {i:i*2 for i in range(1,5)}
# 方式7:使用fromkeys
dic = dict.fromkeys(('k1','k2'),666)
print(dic) # 打印结果:{'k1':666,'k2':666}
# 字典的键必须是可哈希的，即不可变的
dic = {['Name']:'baby'} # 运行结果:TypeError: unhashable type: 'list'

对键值的操作

dic = {'name':'baby','age':18}
# 查询
print(dic['name']) # 打印结果:baby
print(dic.get('name')) # 打印结果:baby
# 删除
dic = {'name':'baby','age':18}
del dic['name']
print(dic) # 打印结果:{'age':18}

dic = {'name':'baby','age':18}
dic.pop('name')
print(dic) # 打印结果:{'age':18}

dic = {'name':'baby','age':18}
# popitem在3.5版本之前是随机删除,3.6之后为删除最后一个，有返回值
dic = dic.popitem()

dic = {'name':'baby','age':18}
# 清空字典
dic.clear()
print(dic) # {} 
# 修改
dic = {'name':'baby','age':18}
dic['age'] = 19
print(dic) # 打印结果:{'name':'baby','age':19}
# update
dic = {'name':'baby','age':18}
dic.update({'sex':'男'})
print(dic) # 打印结果：{'name':'baby','age':18,‘sex’:'男'}

dic = {'name':'baby','age':18}
dic.update(sex='男')
print(dic) # 打印结果:{'name':'baby','age':18,‘sex’:'男'}

dic = {'name':'baby','age':18}
dic.update([('sex','男'),('School','北大')])
print(dic) # 打印结果:{'name':'baby','age':18,‘sex’:'男','School':'北大'}

# 增
dic = {'name':'baby','age':18}
dic['sex'] = '男'
print(dic) # 打印结果:{'name':'baby','age':18,‘sex’:'男'}

# setdefault
dic = {'name':'baby','age':18}
dic.setdefault('sex','男')
print(dic) # 打印结果:{'name':'baby','age':18,‘sex’:'男'}

copy

dic = {'name':'baby','age':18}
# dict.copy()属于深拷贝
dic2 = dic.copy()
print(dic2) # {'name':'baby','age':18}
print(id(dic),id(dic)) # 2359344069352 2359361591960

字典的遍历

dic = {'name':'baby','age':18}
# keys()遍历字典的键
for key in dic.keys():
	print(key) # name # age

# values()遍历字典的值
for value in dic.values():
	print(value) # baby # 18

# items() 遍历字典的键值对,返回的是tuple元组
for key,value in dic.items():
	print(f'{key}:{value}') # name:baby # age:18		

元组

元组可以看做不可修改的列表，或者可哈希的列表
因为元组不可修改，所以元组只能查看，其他的操作几乎与列表相同

切片

切片格式:元组名[start:end：step],start:起始索引(默认值为0)，end:结束索引，step:步长(默认值为1),可为正整数或负正整数,正数时正向取值，负数时负向取值

t = (1,2,3,4,5,6)
t2 = t[0:3:1]
print(t2) # (1,2,3)

count

统计某个元素在元组中出现的次数

t = ('azuo','azuo',1,2)
print(t.count()) # 2

index

查询某个元素在元组中出现的索引位置

t = (1,2,3,4,5,6)
print(t.index(2)) # 1

len

t = (1,2,3,4,5,6)
print(len(t)) # 6
print(t.__len__()) # 6

str字符串

切片

和元组，列表的切片相同

split()

字符串可以通过某个字符，使用split方法切割，返回值是一个list列表

str1 = 'H,e,l,l,o'
list1 = str1.split(',')
print(list1) # [H,e,l,l,o]

字符串的检索

# find 检索字符在字符串中出现的下标位置,如果没有则返回-1
str1 = 'hello'
print(str1.find('e')) # 1
print(str1.find('a')) # -1

# index 检索字符在字符串中出现的下标位置,如果没有则抛出异常 ValueError
print(str1.index('e')) # 1
print(str1.index('a')) # 报错 ValueError: substring not found

# startswith() 用于检索字符串是否以指定子字符串开头,如果是返回True,否则返回False。
# 第一个参数表示用于检索的字符串，第二个为可选参数,表示检索的开始下标，默认为0,第三个为可选参数,表示检索的结束位置默认为一直检索到结尾
str1 = 'hello'
print(str1.stratswith('h')) # True

# endswith 用于检索字符串是否以指定子字符串结尾,如果是返回True,否则返回False。
str1 = 'hello'
print(str1.endswith('h')) # False

大小写转换

str1 = 'HELLO'
# lower 将字符串全部转换成小写
print(str1.lower()) # hello

str1 = hello
# upper 将字符串全部转换成大写
print(str1.upper()) # HELLO

去除空白符

# strip 去除字符串左右的空白字符
str1 = ' hello '
pirnt(str1.strip()) # hello

# lstrip 去除字符串左边的空白字符
str1 = '\thello'
pirnt(str1.lstrip()) # hello

# rstrip 去除字符串右边的空白字符
pirnt(str1.lstrip()) # hello

集合set

集合的每一个元素都不能重复，而且集合是无序的

集合的创建

set1 = {1,2,'barry'}
set2 = set((1,2,'barry'))
set3 = set({1,2,'barry'})
set4 = set([1,2,'barry'])
print(set1,set2,set3,set4) # {1, 2, 'barry'} {1, 2, 'barry'} {1, 2, 'barry'} {1, 2, 'barry'}

集合的增

set1 = {1,2,'barry'}
set1.add(3)
print(set1) # {1, 2, 3, 'barry'}

# update 迭代着增加,注意参数不可以是数值类型(int,float)
set1 = {1,2,'barry'}
set1.update('a')
print(set1) # 1,2,'a','barry'}

set1 = {1,2,'barry'}
set1.update([1,2,3])
print(set1) # {1,2,3,'babrry'}

set1 = {1,2,'barry'}
set1.update((1,2,3,4))
print(set1) # {1,2,3,4,'babrry'}

set1 = {1,2,'barry'}
# 如果update参数是一个字典，那么集合迭代的值是键
set1.update({'name':'azuo'})
print(set1) # {1,2,'barry','name'}

集合的删

# remove 删除某个元素
set1 = {1,2,'barry'}
set1.remove(1)
print(set1) # {1,'barry'}

# pop随机删除某个元素
set1 = {1,2,'barry'}
set1.pop()
print(set1) # {2,'barry'}

# del 删除集合
del set1
set1 = {1,2,'barry'}
set1.clear()
print(set1) # set()
# clear 清空集合

交集

set1 = {1,2,3}
set2 = {1,2,4}
print(set1 & set2) # {1,2}
print(set1.intersection(set2)) # {1,2}

反交集

set1 = {1,2,3,4,5,6}
set2 = {1,2,3}
print(set1 ^ set2) # {4,5,6}
print(set1.symmetric_difference(set2)) # {4,5,6}

并集

set1 = {1,2,3}
set2 = {1,2,4}
print(set1 | set2) # {1,2,3,4}
print(set1.union(set2)) # {1,2,3,4}

差集

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2)  # {1, 2, 3}
print(set1.difference(set2))  # {1, 2, 3}

子集和超集

# 子集
set1 = {1,2,3,4,5,6}
set2 = {1,2,3}
print(set2.issubset(set1)) # True
print(set2 < set1) # True

# 超集
set1 = {1,2,3,4,5,6}
set2 = {1,2,3}
print(set1 > set2) # True
print(set1.issuperset(set2)) # True

frozenset不可变集合，让集合变成不可变类型。

s = frozenset('barry')
print(s,type(s))  # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>

布尔值bool

布尔值只有两种值,True,False
真 1 True
假 0 False

int bool str的相互转换

# int 和 bool的相互转换
print(bool(10)) # True 不等于0的数即为True
print(bool(30)) # True
print(bool(0)) # False 0即False

print(int(True)) # 1
print(int(False)) # 0

# bool和str的相互转换
str1 = str(True)
print(str1,type(str1)) # True <class 'str'>
str2 = 'haha'
str3 = ''
# 非空的字符串转换成布尔值即为True
print(bool(str2)) # True
# 空的字符串转换成布尔值即为False
print(bool(str3)) # False

#int和str的相互转换
int1 = int('100')
print(int1,type(str1)) # 100 <class 'int'>
str1 = str(100)
print(str1,type(str1)) # 100 <class 'str'>