Python数据类型

最新推荐文章于 2023-07-21 20:57:15 发布

萌新驾临

最新推荐文章于 2023-07-21 20:57:15 发布

阅读量120

点赞数

文章标签：基础

本文链接：https://blog.csdn.net/qq_43533693/article/details/102505170

版权

Python基础专栏收录该内容

6 篇文章 0 订阅

订阅专栏

函数

查找函数：object.index(数据[,开始位置下标，结束位置下标])：查找到返回下标，找不到返回错误
计数函数：object.count(数据)，计算数据在object里面出现的次数
长度函数：len(object)，计算数据的长度或个数，公共函数
判断是否存在：in 和 not in；公共函数

print(‘lisa’ in str1)

列表list:[]

增加数据

append(数据)：添加任意数据到列表里，若是序列，则把序列完整添加进去。
extend(数据)：添加数据时，若是序列，一个一个拆开，拆开后一个一个的添加！包括字符串
insert(位置下标，数据)：在指定位置添加数据，若位置已经存在数据，就将其移到后面，新添加数据

删除数据

del 目标或 del(目标)：删除数据的存在
pop()：删除指定下标的数据，若不指定，则删除最后一个数据，并将其返回，不会删除其存在
remove(指定的数据)：
clear()：清空数据，不会删除存在

修改数据

直接赋值：name_list[0] = aa
逆序 reverse()：重新排序，并逆序（插入的顺序），改变了原数据
排序：sort(key=None,reverse=True)：默认为从小到大排序，reverse的值为True则降序
复制：copy()：完全复制，与原数据互不相干
for循环：类似fore：for i in name_list:

随机数： random依赖，random.randint(start,end)：左右都包括，只会出现整数

list1 = []
# 添加数据
list1.append(1)
list1.append('3')
list1.extend('123') # 分解数据再添加，若不能分解，则直接添加，可添加序列，元组，字典
list1.extend((10, 20))
list1.extend({'name': 'zhangs', 'age': 18}) # 'name', 'age',
list1.insert(10,'2') # 指定位置添加元素，若位置不存在，则添加到最后
print(list1) # [1, '3', '1', '2', '3', 10, 20, 'name', 'age', '2']
# 删除数据
pop_num = list1.pop() # 默认删除最后一位，可以指定下标，并以原本的类型将其返回
print(list1, pop_num, type(pop_num)) # [1, '3', '1', '2', '3', 10, 20, 'name', 'age'] 2 <class 'str'>
remove_num = list1.remove('3') # 指定数据删除，不可用下标来指定，不返回删除数据
print(list1, remove_num, type(remove_num))
# del(list1) # 删除数据的存在
# print(list1)
# del list1
# print(list1)
list1.clear() # 清空所有数据，不会删除数据的存在
print(list1) # []
# 改变数据
list1.append(1)
list1[0] = '2' # 指定下标改变
print(list1)

# 查询数据，大多查询方式都能用
for i in enumerate(list1):
    print(i, type(i)) # 返回的是元组
print('-----------------------')
# 排序，返回None，
# 升序排序reverse的值为False，
# 降序排序就用True
list1 = [1,3,5,4,8]
print(list1.sort(key=None, reverse=False))
print(list1)
# 反序，并非排序，只是简单地排序
print(list1.reverse())
print(list1)
print('-----------------------')
# copy()复制方法，深层复制，两者毫不相关
list2 = list1.copy()
print('这是list1', list1)
print('这是list2', list2)
print('改变list1的值')
list1[0] = 0
print('这是list1', list1)
print('这是list2', list2)

元组：tuple:(1,2,3)

与列表的不同是：数据不能修改

定义元组

使用小括号，且用逗号隔开各个数据，数据可以是不同的数据类型
单个数据的元组：t1 = (10,)：不加逗号则变为了int类型
多个数据的元组：t2 = (10,210)

常见操作

按下标查询
index()，如果数据存在，则返回对应的下标，否则报错
count()，统计某个数据在当前元组出现的次数
len()：统计元组数据的个数

元组数据的修改【重点】

元组内的直接数据如果修改则会报错

t1 = (1,3,3) ·#替换了一个新元组

元组内的列表数据里面的数据可以修改！

t2 = (2,3,465.[5,6])

tuple1 = (1, 3, 5, [0, 2, 4])
# 元组一般不可改变，只有元组里面有序列或字典等可修改的序列数据才可以修改
# 强行修改会报错！
tuple1[3].clear()
print(tuple1)
# 可以使用切片创建一个新元组用于添加数据
tuple1 = tuple1[1:] + ('添加的数据', )
print(tuple1)

字典

字典不支持下标，是以键值对来存储数据的，用逗号隔开！存在大括号里

有数据字典：dict1 = {‘name’: ‘张三’, ‘age’:123}
无数据字典，空字典：dict2 = {} 或 dict3 = dict()

常见操作

新增数据：dict1[‘id’] = 110，若原本存在则将其替换！字典是可变类型！
删除数据：del dict1[‘age’]：指定删除键值对！key不存在就报错！del(dict1)，删除其存在！clear()：清空数据
修改数据：字典序列[key] = 值；
查找数据：如果查找的key存在，则返回数据，若不存在，则会报错！
- 字典序列.get(key,默认值)：若key不存在，则返回默认值，如果省略第二个参数，则返回None
- 字典序列.keys()：得到字典的所有key值
- 字典序列.values()：得到字典的所有value
- 字典序列.items()：每一个键值对组成一个元组，元组又会组成一个列表

# 空字典
dict1 = {}
# 添加数据
print('添加数据')
dict1['id'] = 1
dict1['name'] = '测试'
print(dict1)
# 修改数据，若key不存在，便添加数据
dict1['name'] = '正式'
dict1['age'] = 18
print(dict1)
# 删除数据，只有del和clear
print('删除数据')
dict1['测试'] = '删除'
print(dict1)
del dict1['测试']
print(dict1)
dict1.clear()
print(dict1)
# 查询数据
# get(key值，, 默认值)若key不存在，则返回默认值，默认值为None
print('查询数据')
print(dict1.get('id','该数据不存在'))
dict1['id'] = 1
dict1['name'] = '正式'
dict1['age'] = 18
print(dict1.keys()) # 类型为dict_keys,得到所有key值
print(type(dict1.keys()))
print(dict1.values()) # 类型为dict_values,得到所有value
print(type(dict1.values()))
print('使用迭代器')
item = dict1.items()
print(item)
print(type(item)) # 类型是dict_items，里面是一个列表
# 每一个键值对组成一个元组，元组又会组成一个列表
for i in item:  # i 是一个元组
    print(type(i))
    print('key==', i[0])
    print('value==', i[1])

排序

# sorted()
d = {'d1':2, 'd2':4, 'd4':1,'d3':3,}
for k in sorted(d):
    print(k,d[k])
d = {'d1':2, 'd2':4, 'd4':1,'d3':3,}
for k in sorted(d,key=d.__getitem__):
    print(k,d[k])

集合

创建集合可以用{}或set()，空集合只能用set()

set1 = {1,3,5}，set2 = set(‘abcdefg’)

集合里的数据顺序与写入的顺序不一定相同，集合具有不可重复性！

增加数据

因为集合具有去重功能，所以当追加的数据是集合里面已有的数据，则不进行任何操作！

add()，用来追加的是单一数据，不会返回数据
update()，追加的数据是序列！

删除数据

remove()，删除指定的数据，若不存在则会报错！
discard()，删除指定的数据，若不存在也不会报错
pop()，随机删除数据，并把删除的返回

查找数据

in 是否存在？返回布尔值
not in 是否不存在？返回布尔值

运算符

“+”号：合并，支持字符串，列表，元组

print(str1 + str2),列表和元组就是把数据放到了一起，字典强加会报错！

“*”号：复制，支持字符串，列表，元组，用于复制几遍

print(‘a’*5)==>aaaaa

in 和 not in ：支持字符串，列表，元组，字典

公共方法

len()：计算容器元素的个数

len(容器)，计算字典时看有多少个键值对！

del 或del()：删除，可以删除其存在，也可以删除指定列表的数据
max()：返回容器的最大值
min()：返回容器的最小值
range(start,end,step)：生成从start开始到end，步长为step，供for循环使用，start可以省略，默认为0，step可以省略，默认为1，不包括end

print(range(1,10,1)) ==> range(1,10)

enumerate()：函数用于将一个可便利的数据对象（如列表，元组或字符串）组合为一个索引序列，返回是元组，同时列出数据和数据下标，一般用在for循环0

enumerate(可遍历的对象,start=0)：for index, char in enumerate：下标是index，数据是char enumerate(list,start=1)：start用于指定index的开始，会改变下标，不会改变数据，r

tuple(),set(),list()：将其他类型的序列数据转换为想要的类型数据

推导式

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

列表推导式

用一个表达式创建一个有规律的列表或控制一个有规律的列表

创建一个1到10的有规律的列表

list1 = []
	while i < 10:
    	list1.append(i)
    	i+=1
	print(list1)

可以改为：

 list1 = [i for i in range(10)]  
 print(list1)
 list1 = [i for i in range(10) if i % 2 == 0]：带if的列表推导式

# 多for循环实现列表推导式创建元组的列表
# [(1,0),(1,1)(1,2),(2,0),(2,1),(2,2)]
list1 = [(i,j) for i in range(1,3) for j in range(3)]

字典推导式

两个列表合并成一个字典或提取字典中目标数据
- 例子：创建一个key为1-5，value为这个数字的二次方
- dict1 = {i: i**2 for i in range(1, 6)}
将两个列表合并成一个字典：list1和list2
- dict1 = {list1[i]: list2[i] for i in range(len(list1))}
- 两个列表数据个数若不同，取短的那个
提取字典中的目标数据：

counts = {'MBP': 268, 'HP': 125, 'Lenvo': 199 'DELL': 201}  
count = {key: value for key, value in counts.items() if value >= 200}

集合推导式：

list1 = [1, 1, 2]
set1 = {i ** 2 for i in list1}
print(set1) # {1,4}

遍历方式

in操作符

使用range()或者xrange()函数遍历

使用iter()函数遍历。它是一个迭代器函数

使用enumerate()函数遍历。该函数用于遍历序列中的元素及其下标

函数

定义函数

必须先定义后调用！

def 函数名(参数):
	代码1
	代码2
def sel_func():
	print('')
	print('')

调用函数

sel_func()

函数的返回值

跟java一样，用return

函数的说明文档

help(函数名)—help(len)：查看函数的说明文档！

def 函数名(参数):
	""" 说明文档的位置"""
	代码1
	代码2

函数说明文档的高级使用：

def 函数名(参数):
	"""
	测试函数
	:param a:
	:param b:
	:return:
	"""
	代码1
	代码2

在函数内部修改全局变量

先用global用来声明a是全局变量，然后就可以修改了

 a = 100
 def global_fun:
 	global a
 	a = 200
 print(a) # 200

返回多个值

return a, b
默认返回一个元组！

关键字参数

demo_fun(name, age, gender)
demo_fun(‘Tom’, gender=‘man’, age=18)
函数调用时，如果有位置参数，位置参数就必须是在关键字参数的前面，但关键字参数之间存在先后顺序

缺省参数

缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有【位置参数】必须出现在默认参数前面，包括函数定义和调用）
函数调用时，如果为缺省函数则修改默认参数；否则使用这个默认值

不定长参数

可变参数，用于不去定调用的时候会传递多少个参数（不传参也可以）的场景。可用包裹位置参数或包裹关键字参数
包裹位置传递：传进的所有参数都会被args接收，会根据的传进来的位置形成一个元组，args就是一个元组，组包

def user_info(*args):
	print(args)
user_info('Tom', 18, 110)

包裹关键字传递：就是一个组包的过程,，搜集所有关键字和参数，返回一个字典

def user_info(**kwargs):
	print(kwargs)
uer_info(name='Tom', age=18, id =110)

拆包和交换变量值

元组拆包：数据的个数问题

def return_num():
	return 100, 200
num1, num2 = return_num()
print(num1) # 100
print(num2) # 200

字典拆包：

dict1 = {'name':'Tom', 'age':18}
a, b = dict1
#对字典进行拆包的话，会得到字典的key
print(a) # name
print(b) # age
print(dict1[a]) # Tom
print(dict1[b]) # 18

交换变量值的方法一

借助第三方的存储变量

c = 0
c = a
a = b
b = c

交换变量值的方法二

a, b = 1, 2
a, b = b, a
print(a, b) # 2, 1

引用

Python中，数据的传递都是通过引用！类似java里的值传递和引用传递，可以使用id()函数来判断是否为同一引用，返回地址标识
- 不可变类型数据，例如int，改一只动一个，数据一般不会改变，标识会变
- 可变类型，如list数据，改一动全部，标识不变

数据类型

数据呢个直接修改，不会新开辟内存的就是可变类型，修改后，标识也改变的是不可变类型

可变类型
- 列表
- 字典
- 集合
不可变类型
- 整型
- 浮点型
- 字符串
- 元组

作用域

Local 局部变量

在程序中进行变量赋值，不进行任何的特殊说明所有变量都是局部变量

enclosing 嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部变量

global，全局变量，就是模块级别定义的变量；

使用global，可以将函数内的局部变量变为全局变量，在函数外也能访问

built-in，系统固定模块里面的变量，比如int，byte，array等

变量名解析规则

查找顺序：LEGB法则

萌新驾临

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录