python-tuple(元组)-set(集合)-list(列表)-dictionary(字典)和Python数据类型转换函数

简介: python-tuple(元组)-set(集合)-list(列表)-dictionary(字典)和Python数据类型转换函数

1.Python 不同数据类型 操作2

1.1 Tuple(元组)

元组创建很简单,只需要在括号()中添加元素,并使用逗号隔开即可,并且元组中的元素不能改变!

操作符 描述
len() 计算元素个数
+ 连接
* 复制
in 元素是否存在
[] 读取第几个元素
[ : ] 截取字符串中的一部分,遵循左闭右开原则

案例1

len(tup1),输出结果:4
tup1 + (3,4),输出结果:(‘hello’, ‘world’, 1, 2, 3, 4)
(‘Hi!’,) * 4 ,输出结果:(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)
3 in (1, 2, 3),输出结果:True
[0],输出结果:hello
[0:2],输出结果:(‘hello’, ‘world’)

1.2 Set(集合)

集合可以使用大括号 {} 或者set()函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。集合是一个无序的不重复元素序列,集合内的元素可以改变!

操作 描述
set2=set('abcd') 创建集合
set.add(str) 添加元素方法
set.update([1,2],[3,4]) update添加元素,参数可以是列表,元组,字典等
set.remove('str') 移除元素

案例

set1 = {'小黑',20,20}
#add():添加方法
set1.add('大学生')
print(set1) # {'大学生', '小黑', 20}
# update():也可以添加元素,且参数可以是列表,元组,字典等
set1.update([1,2],[3,4])
print(set1) # {1, '大学生', 2, 3, 4, 20, '小黑'}
# remove():移除元素
set1.remove('大学生')
print(set1) # {1, 2, 3, 4, 20, '小黑'}

1.3 List(列表)

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。列表中的元素是可以改变的!常用运算符同元组!

方法名 描述
list.append(obj) 在列表末尾添加新的对象
list.count(obj) 统计某个元素在列表中出现的次数
list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj) 将对象从对应索引位置插入列表
list.pop([index=-1]) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
list.reverse() 反转列表中元素
list.sort( key=None, reverse=False) 对原列表进行排序
list.clear() 清空列表
list.copy() 复制列表
del list[index] 删除列表元素

1.4 Dictionary(字典)

字典的每个键值 key=>value 对用冒号 : 分割,每个对之间用逗号(,)分割,整个字典包括在花括号 {}中.键必须是唯一的,但值则不必。值可以取任何数据类型,但键必须是不可变的,如字符串,数字

数据类型转换函数

操作 描述
d = {key1 : value1, key2 : value2, key3 : value3 } 创建字典
dict[key1] 访问字典的键
dict[key1]='str'/int/float(字典可以是任何值) 修改字典
for i in dict: 遍历字典
dist.get() 访问字典中键对应的值。key存在则返回对应value,键不存在返回None,也可以设定自己的返回参数,设置的方法是:变量名.get(键名,参数)。
dict.values() 查看字典的值
dict.keys() 查看字典的键

案例2

创建字典
d = {key1 : value1, key2 : value2, key3 : value3 }
访问字典的键
dict = {'Name': '小明', 'Age': 20}
print(dict) # {'Name': '小明', 'Age': 20}
print (dict['Name']) # 小明
print (dict['Age']) # 20
修改字典
dict = {'Name': '小明', 'Age': 20}
dict['Name'] = '小黑'
dict['Age'] = 22
print(dict) # {'Name': '小黑', 'Age': 22}
遍历字典
dict = {'Name': '小明', 'Age': 20}
#遍历键
for key in dict.keys():
    print(key)
"""
Name
Age
"""
# 遍历值
for value in dict.values():
    print(value)
"""
小明
20
"""
访问字典中键对应的值
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'北京'}
age = info.get('age')
print(age)
# None
age=info.get('age',18)
print(age)
# 18

2 数据类型转换函数

操作 描述
int() 将float、bool、str类型的数据转换为int类型。float类型转换为int类型时去除小数点后面的数;bool类型转换为int类型时False变为0、True变为1;str类型直接转换为int类型
bool() 将int、float、str类型的数据转换为bool类型。int类型转换为bool类型时0变为False、其他数据变为True;float类型转换为bool时0.0变为False、其他数据变为True;str类型转换为bool类型时不存在数据变为False、存在数据变为True。
float() 将int、bool、str类型的数据转换为float类型数据。int类型转换为float时在末尾添加小数位;bool类型转换为float时False变为0.0,、True变为1.0;str类型直接转换为float类型。
str() 将int、float、bool、list、tuple、set、dict类型的数据转换为str类型
list() 将tuple、set、dict类型的数据转换为list类型。其中dict类型转换为list类型时,获取的列表中存储的值是dict类型变量的key值。
tuple() 将list、set、dict类型的数据转换为tuple类型。其中dict类型转换为tuple类型时获取的元祖中存储的值是dict类型变量的key值。
set() 将list、tuple、dict类型的数据转换为set类型。其中dict类型转换为set类型时获取的元祖中存储的值是dict类型变量的key值。
dict() 因为dict字典类型是键值对对应,所以list、tuple、set类型没法转换
sorted(tup,reverse=Flash) 对序列暂时性排序,不改变原序列,可传入参数reverse=Flash(升序)/True(降序),不传入时默认Flash升序排序,

2.1案例3

int()

# 定义float变量
f = 9.99
# 定义bool类型变量
b1 = False
b2 = True
# 定义str类型变量
s = '111'
# 使用int()函数
int1 = int(f)
int2 = int(b1)
int3 = int(b2)
int4 = int(s)
print("int1:",int1) 
print("int1的类型是:",type(int1))
print("-"*10)
print("int2:",int2)
print("int2的类型是:",type(int2))
print("int3:",int3)
print("int3的类型是:",type(int3))
print("-"*10)
print("int3:",int4)
print("int3的类型是:",type(int4))
'''
int1: 9
int1的类型是: <class 'int'>
----------
int2: 0
int2的类型是: <class 'int'>
int3: 1
int3的类型是: <class 'int'>
----------
int3: 111
int3的类型是: <class 'int'>
'''

bool()

# 定义int变量
i1 = 0
i2 = -1
i3 = 1
# 定义float变量
f1 = 0.0
f2 = -1.0
f3 = 1.0
# 定义str变量
s1 = ''
s2 = '0'
s3 = '-1'
s4 = '1'
s5 = 'A'
# 使用bool()函数
b1 = bool(i1)
b2 = bool(i2)
b3 = bool(i3)
b4 = bool(f1)
b5 = bool(f2)
b6 = bool(f3)
b7 = bool(s1)
b8 = bool(s2)
b9 = bool(s3)
b10 = bool(s4)
b11 = bool(s5)
print("b1:",b1) 
print("b1的类型是:",type(b1))
print("b2:",b2) 
print("b2的类型是:",type(b2))
print("b3:",b3) 
print("b3的类型是:",type(b3))
print("-"*10)
print("b4:",b4) 
print("b4的类型是:",type(b4))
print("b5:",b5) 
print("b5的类型是:",type(b5))
print("b6:",b6) 
print("b6的类型是:",type(b6))
print("-"*10)
print("b7:",b7) 
print("b7的类型是:",type(b7))
print("b8:",b8) 
print("b8的类型是:",type(b8))
print("b9:",b9) 
print("b9的类型是:",type(b9))
print("b10:",b10) 
print("b10的类型是:",type(b10))
print("b11:",b11) 
print("b11的类型是:",type(b11))
'''
b1: False
b1的类型是: <class 'bool'>
b2: True
b2的类型是: <class 'bool'>
b3: True
b3的类型是: <class 'bool'>

float()

# 定义int变量
i1 = 1
i2 = -1
# 定义bool变量
b1 = False
b2 = True
# 定义str变量
s1 = '99'
# 使用float()函数
f1 = float(i1)
f2 = float(i2)
f3 = float(b1)
f4 = float(b2)
f5 = float(s1)
print("f1:",f1) 
print("f1的类型是:",type(f1))
print("f2:",f2) 
print("f2的类型是:",type(f2))
print("-"*10)
print("f3:",f3) 
print("f3的类型是:",type(f3))
print("f4:",f4) 
print("f4的类型是:",type(f4))
print("-"*10)
print("f5:",f5) 
print("f5的类型是:",type(f5))
'''
f1: 1.0
f1的类型是: <class 'float'>
f2: -1.0
f2的类型是: <class 'float'>
----------
f3: 0.0
f3的类型是: <class 'float'>
f4: 1.0
f4的类型是: <class 'float'>
----------
f5: 99.0
f5的类型是: <class 'float'>
'''

str()

# 定义int类型变量
i1 = 1
# 定义float类型变量
f1 = 9.99
# 定义bool类型变量
b1 = False
b2 = True
# 定义list类型变量
l1 = [1, 2, 'a', 'b']
# 定义tuple类型变量
t1 = (1, 2, 'a', 'b')
# 定义set类型变量
s1 = {1, 2, 'a', 'b'}
# 定义dict类型变量
d1 = {'name': '小白', 'age':18}
# 使用str()函数
str1 = str(i1)
str2 = str(f1)
str3 = str(b1)
str4 = str(b2)
str5 = str(l1)
str6 = str(t1)
str7 = str(s1)
str8 = str(d1)
print("str1:",str1) 
print("str1的类型是:",type(str1))
print("-"*10)
print("str2:",str2) 
print("str2的类型是:",type(str2))
print("-"*10)
print("str3:",str3) 
print("str3的类型是:",type(str3))
print("str4:",str4) 
print("str4的类型是:",type(str4))
print("-"*10)
print("str5:",str5) 
print("str5的类型是:",type(str5))
print("-"*10)
print("str6:",str6) 
print("str6的类型是:",type(str6))
print("-"*10)
print("str7:",str7) 
print("str7的类型是:",type(str7))
print("-"*10)
print("str8:",str8) 
print("str8的类型是:",type(str8))
'''
str1: 1
str1的类型是: <class 'str'>
----------
str2: 9.99
str2的类型是: <class 'str'>
----------
str3: False
str3的类型是: <class 'str'>
str4: True
str4的类型是: <class 'str'>
----------
str5: [1, 2, 'a', 'b']
str5的类型是: <class 'str'>
----------
str6: (1, 2, 'a', 'b')
str6的类型是: <class 'str'>
----------
str7: {'b', 1, 2, 'a'}
str7的类型是: <class 'str'>
----------
str8: {'name': '小白', 'age': 18}
str8的类型是: <class 'str'>
'''

list()

# 定义tuple变量
t1 = (1, 2, 'a', 'b')
# 定义set变量
s1 = {1, 2, 'a', 'b'}
# 定义dict变量
d1 = {'name': '小白', 'age':18}
# 使用list()函数
l1 = list(t1)
l2 = list(s1)
l3 = list(d1)
print("l1:",l1) 
print("l1的类型是:",type(l1))
print("-"*10)
print("l2:",l2) 
print("l2的类型是:",type(l2))
print("-"*10)
print("l3:",l3) 
print("l3的类型是:",type(l3))
'''
l1: [1, 2, 'a', 'b']
l1的类型是: <class 'list'>
----------
l2: [1, 2, 'b', 'a']
l2的类型是: <class 'list'>
----------
l3: ['name', 'age']
l3的类型是: <class 'list'>
'''

tuple()

# 定义list变量
l1 = [1, 2, 'a', 'b']
# 定义set变量
s1 = {1, 2, 'a', 'b'}
# 定义dict变量
d1 = {'name': '小白', 'age':18}
# 使用tuple()函数
t1 = tuple(l1)
t2 = tuple(s1)
t3 = tuple(d1)
print("t1:",t1) 
print("l1的类型是:",type(t1))
print("-"*10)
print("t2:",t2) 
print("t2的类型是:",type(t2))
print("-"*10)
print("t3:",t3) 
print("t3的类型是:",type(t3))
'''
t1: (1, 2, 'a', 'b')
l1的类型是: <class 'tuple'>
----------
t2: (1, 2, 'b', 'a')
t2的类型是: <class 'tuple'>
----------
t3: ('name', 'age')
t3的类型是: <class 'tuple'>
'''

set()

# 定义list变量
l1 = [1, 2, 'a', 'b']
# 定义tuple变量
t1 = (1, 2, 'a', 'b')
# 定义dict变量
d1 = {'name': '小白', 'age':18}
# 使用set()函数
s1 = set(l1)
s2 = set(t1)
s3 = set(d1)
print("s1:",s1) 
print("s1的类型是:",type(s1))
print("-"*10)
print("s2:",s2) 
print("s2的类型是:",type(s2))
print("-"*10)
print("s3:",s3) 
print("s3的类型是:",type(s3))
'''
s1: {1, 2, 'b', 'a'}
s1的类型是: <class 'set'>
----------
s2: {1, 2, 'b', 'a'}
s2的类型是: <class 'set'>
----------
s3: {'age', 'name'}
s3的类型是: <class 'set'>
'''

dict()

# 创建空的字典
d1 = dict()
print("d1:",d1)
print("d1的类型是:",type(d1))
'''
d1: {}
d1的类型是: <class 'dict'>
'''

sorted(tup,reverse=Flash)

my_list=[1,2,4,3,6,5]
print('不传入参数时默认升序排序',sorted(my_list))
# [1, 2, 3, 4, 5, 6]
print('升序排序',sorted(my_list,reverse=False))
# [1, 2, 3, 4, 5, 6]
print('降序排序',sorted(my_list,reverse=True))
# [6, 5, 4, 3, 2, 1]
print('不改变序列',my_list)
# [1, 2, 4, 3, 6, 5]
相关文章
|
1天前
|
存储 索引 Python
python学习7-元组
python学习7-元组
|
4天前
|
存储 安全 索引
「Python系列」Python元组
Python中的元组(Tuple)是一种不可变的有序序列类型,它允许你存储多个不同类型的元素,并且这些元素在元组中是按照特定的顺序排列的。一旦一个元组被创建,你就不能修改它(即不能添加、删除或更改元组中的元素),这使得元组成为一种非常安全的数据结构,因为一旦它们被创建,就不
15 1
|
14天前
|
存储 Java 程序员
【Python】6. 基础语法(4) -- 列表+元组+字典篇
【Python】6. 基础语法(4) -- 列表+元组+字典篇
39 1
|
存储 C++ 索引
【python】—— 列表和元组详解
【python】—— 列表和元组详解
|
1月前
|
存储 Python
请简述Python中的列表、元组和字典的区别?
请简述Python中的列表、元组和字典的区别?
12 1
|
1月前
|
存储 安全 Java
Python教程第3章 | 集合(List列表、Tuple元组、Dict字典、Set)
Python 列表、无序列表、字典、元组增删改查基本用法和注意事项
50 1
|
1月前
|
存储 数据可视化 索引
Python中List列表的妙用
Python中List列表的妙用
16 0
|
1月前
|
存储 安全 索引
元组是什么,python怎么使用元组
元组是什么,python怎么使用元组
19 1
|
3月前
|
存储 Swift
在Swift编程语言中,字典(Dictionary)
在Swift编程语言中,字典(Dictionary)
34 3
|
6月前
|
存储 Java Python
多重字典(Multi-Level Dictionary)
多重字典(Multi-Level Dictionary)是一种将多个字典组合在一起的数据结构,用于解决需要在多个维度上查找数据的问题。多重字典可以看作是一个嵌套的字典,每个字典都可以作为其他字典的键。 使用多重字典的场景:
44 3