农家乐网站 建设,建立免费空间网站,wordpress图片库插件,seo顾问服务深圳python内置的数据结构有#xff1a; 列表(list) 元组(tuple) 字典(dict) 集合(set) 在python语言中#xff0c;以上4种数据结构和基础数据类型#xff08;整数、浮点数等#xff09;统称为“内置类型”#xff08;Built-in Types#xff09;。
1. 列表(list)
参考…python内置的数据结构有 列表(list) 元组(tuple) 字典(dict) 集合(set) 在python语言中以上4种数据结构和基础数据类型整数、浮点数等统称为“内置类型”Built-in Types。
1. 列表(list)
参考http://wed.xjx100.cn/news/317220.html?actiononClick
1.1. 创建
1.1.1. 使用[] 创建
# 定义空列表
test []
# 使用 list() 构造函数创建列表
test list((apple, banana, cherry))
# 定义非空列表
name [Tom,Jack,John]
pet [cat,dog,bird]# 打印列表
print(name) # [Tom, Jack, John]
print(pet) # [cat, dog, bird]1.1.2. 使用 range() 创建数字 list
range() 为 python 的自有类range() 带有内置的迭代方法iter() 和 next() 它是一个可迭代对象我们可以通过 for 访问 range() 创建的迭代器。 range 类初始化参数说明 range(stop): 从0开始到stop结束不包含 stop返回一个产生整数序列的迭代对象 range(start, stop[, step]): 从 start 开始到 stop 结束不包含 stop返回一个整数序列的迭代对象, step 为他的步长
# 循环输出1-10之间的数字
for num in range(11):print(num,end )
# 输出1-10之间的偶数
for num in range(2,11,2):print(num,end )
# 输出1-10之间的奇数
for num in range(1,11,2):print(num,end )
# 输出1-10之间的奇数的平方
for num in range(1,11,2):print(num**2,end )
# 创建一个数字列表
numbers list(range(1,11))
print(numbers)1.2. 查询
1.2.1. 使用下标查询
使用下标索引来访问列表中的值同样你也可以使用方括号的形式截取字符如下所示
# 通过索引读取列表中的元素索引从0开始-1代表最后一个元素
print(name[0]) # Tom 查看列表中第一个
print(pet[2]) # bird 查看列表中第二个
print(name[-1]) # John 查看列表中最后一个
print(pet[-2]) # dog 查看列表中倒数第二个
print(name[0:2]) # [Tom, Jack] 查看索引2之前的元素1.2.2. 列表切片
切片是 python 序列的重要操作之一适用于列表、元组、字符串、range 对象等类型。切片使用2个冒号分隔的3个数字来完成 第一个数字表示切片的开始位置默认为0 第二个数字表是切片的截止但不包含位置默认为列表长度 第三个数字表示切片的步长(默认为1)当步长省略时顺便可以省略最后一个冒号。 可以使用切片来截取列表中的任何部分得到一个新列表也可以通过切片来修改和删除列表中部分元素甚至可以通过切片操作为列表对象增加元素。与使用下标访问列表元素不同切片操作不会因为下标越界而抛出异常而是简单地在列表尾部截断或者返回一个空列表代码具有更强的健壮性。
# 创建一个列表
pets [cat,dog,duck,pig]
# 1、读取列表中2和3的元素
pets[1:3]
# 2、读取列表中1到4的元素
pets[0:4]
# 3、读取列表中的第一个元素
pets[0]
# 4、读取列表中的最后一个元素
pets[-1]
# 5、读取列表中从第二个元素开始的所有元素
pets[1:]
# 6、读取列表中从第一个元素开始的所有元素
pets[0:]
# 7、读取列表中从倒数第三个元素开始的所有元素
pets[-3:]
# 8、循环输出列表中从倒数第三个元素开始的所有元素
for pet in pets[-3:]:print(pet,end )
# 9.读取列表中从第三个开始的所有数据并组合一下数据
games [王者,吃ji,抢滩登陆]
# friend_games [王者,吃ji]
friend_games games[:2]
print(我喜欢的游戏有:str(games)) # 我喜欢的游戏有:[王者, 吃ji, 抢滩登陆]
print(我朋友喜欢的游戏有:str(friend_games)) # 我朋友喜欢的游戏有:[王者, 吃ji]1.3. 增加
向 python 列表里面添加元素主要有三种方法
1.3.1. append()
append() 对于列表的操作主要实现的是在列表最后添加一个元素并且只能一次添加一个元素并且只能在列表最后 name.append(元素A)
# 在列表末尾添加新元素
name.append(Bob)1.3.2. extend()
extend() 对于列表的操作主要实现的是对于特定列表的扩展和增长可以一次添加多个元素不过也只能添加在列表的最后 name.extend([元素A元素B……])
name.extend([Xgp,Wsd])1.3.3. insert()
insert() 对于列表的操作主要是在列表的特定位置添加想要的元素比较常用这里的特定位置是指元素在列表中的索引号需要注意的是这里的索引号都是从0开始的不是从1开始的。 pet.insert(A, 元素B)表示在列表pet的第A处加入元素B
# 在列表指定位置添加新元素
pet.insert(0,penguin) #在列表最前面添加数据
pet.insert(-2,pig) #在列表倒数第二个添加数据1.4. 修改
使用链表索引直接赋值即可。
1.5. 删除
与之前 python 列表的添加元素相对删减列表里面的一些元素也有三种方法
1.5.1. del m[n]
它的作用是删除列表中索引号为n 的元素这里需要注意的是del是一种操作语句。 del pet[n]
# 根据索引从列表中删除元素
del pet[0] # 删除开头的元素
del pet # 删除列表1.5.2. pop()
它的作用有两个 pop() 返回列表最后一个元素并且删除
temppet.pop() # 这里temp等于列表最后一个元素。pop(n) 弹出指定位置的元素并且删除
print(pet)
temppet.pop(2) # [cat, dog, penguin, bird] 弹出指定位置的元素
print(pet, temp) # [cat, dog, bird] penguin1.5.3. remove()
remove() 的作用是移除列表的特定元素不返回 pet.remove(元素A)
# 根据元素的值进行删除remove()
print(pet) # [cat, dog, penguin, bird] 查看源列表
temppet.remove(cat) #删除cat
print(pet,temp) # [dog, penguin, bird] None 打印列表1.5.4. clear()方法
clear() 方法用于清空列表类似于 del a[:]。 语法 list.clear()
word [A, B, C]
word.clear()
print(word) # []1.6. 排序
1.6.1. 永久排序正索引从头到尾
sort() 排序方法此函数方法对列表内容进行正向排序排序后的新列表会覆盖原列表id不变也就是sort排序方法是直接修改原列表list排序方法。
# 定义列表汽车的品牌
print(原始排序)
brand [audi,bmw,toyota,luhu]
print(brand) # [audi, bmw, toyota, luhu]# 永久排序: sort()
print(正序排序)
brand.sort()
print(brand) # [audi, bmw, luhu, toyota]1.6.2. 临时排序正索引从头到尾
sorted() 方法即可以保留原列表又能得到已经排序好的列表.
#临时排序
print(临时排序)
print(sorted(brand)) # [audi, bmw, luhu, toyota]1.6.3. 倒序从头到尾从尾到头
reverse[True|False] 列表反转排序是把原列表中的元素顺序从左至右的重新存放而不会对列表中的参数进行排序整理。如果需要对列表中的参数进行整理就需要用到列表的另一种排序方式 sort() 正序排序。
# 倒序排序
print(倒序排序:)
brand.sort(reverseTrue)
print(brand) # [toyota, luhu, bmw, audi]1.7. 其他操作
总结
print() # 打印输出
len() # 确定列表项目
type() # 返回变量类型
list() # 转换为列表
max() # 返回列表元素最大值
min() # 返回列表元素最小值
del # 删除列表
append(obj) # 在列表末尾添加新的对象
insert(index, obj) # 在指定位置添加元素
extend(seq) # 将列表元素或任何可迭代的元素添加到当前列表的末尾
count(obj) # 统计某个元素在列表中出现的次数
index(obj) # 返回具有指定值的第一个元素的索引
sort( keyNone, reverseFalse) # 对原列表进行排序
copy() # 复制列表
reverse() # 颠倒列表的顺序
pop([-1]) # 移除列表中的一个元素默认最后一个元素并且返回该元素的值
remove(obj) # 移除列表中某个值的第一个匹配项
clear() # 清空列表1.7.1. 列表拼接复制
#与字符串一样列表之间可以使用 号和 * 号实现元组的连接和复制这就意味着它们可以生成一个新的列表。
# 1、 连接合并
x [1, 2, 3]
y [4, 5, 6]
print(x y) # [1, 2, 3, 4, 5, 6]
# 2、*复制
x [Hello]
print(x * 5) # [Hello, Hello, Hello, Hello, Hello]1.7.2. 嵌套列表
# 使用嵌套列表即在列表里面创建其他列表。
x [1, 2, 3]
y [a, b, c]
z [x, y]
print(z) # [[1, 2, 3], [a, b, c]]1.7.3. 列表比较
# 列表比较需要引入 operator 模块的 eq 方法。
# 导入 operator 模块
import operatora [1, 2]
b [2, 3]
c [2, 3]
print(operator.eq(a, b):, operator.eq(a, b)) # operator.eq(a, b): False
print(operator.eq(b, c):, operator.eq(b, c)) # operator.eq(b, c): True1.7.4. 内置函数
# 打印输出 print()
my_list [pink, True, 1.78, 65]
print(my_list) # [pink, True, 1.78, 65]# 确定列表项目 len()
fruit_list [apple, banana, cherry]
print(len(fruit_list)) # 3# 返回变量类型 type()
info_list [name, gender, age, height, weight]
# 当对info_list使用 type() 确定变量类型时会返回class list表明这是一个列表。
print(type(info_list)) # class list# 转换为list list()
# 将字符串转换为列表
str1 Hello Python
print(list(str1)) # [H, e, l, l, o, , P, y, t, h, o, n]
# 将元组转换为列表
tuple1 (Hello, Python)
print(list(tuple1)) # [Hello, Python]
# 将字典转换为列表
dict1 {Hello: Python, name: pink}
print(list(dict1)) # [Hello, name]
# 将集合转换为列表
set1 {Hello, Python, name, pink}
print(list(set1)) # [Python, name, pink, Hello]
# 将区间转换为列表
range1 range(1, 6)
print(list(range1)) # [1, 2, 3, 4, 5]# 元素最大/小值 max()、min()
list1 [4, 6, 2, 0, -5]
print(max(list1)) # 6
print(min(list1)) # -5
list2 [a, z, A, Z]
print(max(list2)) # z
print(min(list2)) # A# 元素出现次数 count()
# count() 方法用于统计某个元素在列表中出现的次数。
# 语法list.count(value)
# 必需。任何类型字符串、数字、列表、元组等。要搜索的值。
num [1, 4, 2, 9, 7, 8, 9, 3, 1]
print(num.count(9)) # 2# 指定值索引 index()
# index() 方法用于从列表中找出某个值第一个匹配项的索引位置。
# 语法 list.index(element)
# element 必需。任何类型字符串、数字、列表等。要搜索的值。
num [4, 55, 64, 32, 16, 32]
print(num.index(32)) # 3# 复制列表 copy()
# copy() 方法用于复制列表类似于 a[:]。
# 语法 list.copy()
fruits [apple, banana, cherry, orange]
x fruits.copy()
print(x) # [apple, banana, cherry, orange]# 颠倒列表顺序 reverse()
# reverse() 方法用于反向列表中元素。
# 语法list.reverse()
fruits [apple, banana, cherry]
fruits.reverse()
print(fruits) # [cherry, banana, apple]2. 元组(tuple)
python 的元组与列表类似不同之处在于元组的元素不能修改。 元组使用小括号列表使用方括号。 元组创建很简单只需要在括号中添加元素并使用逗号隔开即可。
2.1. 创建
# 空
_tup ()
print(_tup, type(_tup)) # () class tuple
# 一个元素的写法
_tup (666,) # 此处加‘,’的原因是要区分括号的作用
print(_tup, type(_tup)) # (666,) class tuple
_tup (666)
print(_tup, type(_tup)) # 666 class int
# 多个元素的写法
(1,2,3)
# 多个对象以逗号隔开默认为元组
_tup 1,2,3,sz
print(_tup, type(_tup)) # (1, 2, 3, sz) class tuple
# 从列表转换成元组
_lst [1, 2, 3, 4, 5]
_tup tuple(_lst)
print(_tup, type(_tup)) # (1, 2, 3, 4, 5) class tuple
# 元组嵌套
(1,2,(a,b)) # 元组中的元素可以是元组 2.2. 查询
获取单个元素tuple[index] index 为索引可以为负
#定义元组
numbers (4,5,6)
print(numbers[0]) #查看元组中第一个元素for num in numbers:print(num,end )获取多个元素切片 tuple[startendstep] start 查询的开始位置 end 查询的结束位置 step 查询的步长
2.3. 增加拼接和复制
与字符串一样元组之间可以使用 号和 * 号进行运算。这就意味着他们可以组合和复制运算后会生成一个新的元组。
# 计算元素个数
print(len((1, 2, 3))) # 3
# 连接
print((1, 2, 3) (4, 5, 6)) # (1, 2, 3, 4, 5, 6)
# 复制
print((Hi!,) * 4) # (Hi!, Hi!, Hi!, Hi!)
# 元素是否存在
print(3 in (1, 2, 3)) # True
# 迭代
for x in (1, 2, 3):print (x,) # 1\n 2\n 32.4. 修改
元组中的元素值是不允许修改的但我们可以对元组进行连接组合如下实例:
print(numbers)
numbers (0,1,2) # 对元祖重新赋值允许
print(numbers)2.5. 删除
print(numbers) #查看元组
del numbers #删除元组
print (删除后的元组 numbers : )
print(numbers) #因为删除了元组所以看不到了就会报错2.6. 函数操作
2.6.1. 获取操作
# 统计元组中指定元素item的个数
tuple.count(item)
# 获取元组中指定元素item的索引
tuple.index(item)
# 统计元组中元素的个数
len(tuple)
# 返回元组中元素最大的值
max(tuple)
# 返回元组中元素最小的值
min(tuple)2.6.2. 判断操作
# 元素 in 元组
# 元素 not in 元组
t1 (1,2,3,4,5,6,a,a,abc)
print(1 in t1) #输出 True
print(5 not in t1) #输出 False
print(a in t1) #输出 True2.6.3. 比较操作
# 比较运算符
t1 (1,2,3,4,5,6,a,a,abc)
t2 (5,2,6,4,8,2,)
print(t2 t1) #输出 False
print(t2 t1) #输出 True
print(t2 t1) #输出 False2.6.4. 拆包
# 拆包
a,b ,c (10,20,30)
print(a) #输出 10
print(b) #输出 20
print(c) #输出 302.6.5. 转换为字符串
_tup (apple, 10, True)
print(_tup, type(_tup)) # (apple, 10, True) class tuple
# 使用str()
_str str(_tup)
print(_str, type(_str)) # (apple, 10, True) class str
# 使用列表推导的方式生成字符串
_str2 , .join([str(item) for item in _tup]) # 用“, ”分割
print(_str2, type(_str2)) # apple, 10, True class str需要注意的是转换后的字符串会保留元组的原始结构包括圆括号和逗号。这是因为 str() 函数将元组视为一个整体进行转换。 参考https://blog.51cto.com/u_16213414/7220752
3. 字典(dict)
字典是一种可变的容器可以存储任意类型的数据 字典中的每个数据都是用键 (key) 进行索引而不像序列可以用下标进行索引 字典中的数据没有先后关系字典的存储是无序的 字典是python中唯一的映射类型**采用键值对key-value**的形式存储数据。key必须是不可变类型如数字、字符串、元组。 字典的表示方式是以{} 括起来以冒号(:)分割的键值对各键值对之间用逗号分隔开 字典的键一般是唯一的如果重复最后的一个键值对会替换前面的 字典的内置方法函数总结
dic.clear() # 清空字典
dic.pop(key) # 移除键同时返回此键所对应的值
dic…popitem() # 随机删除一组键值对同时返回对应的值
dic.copy() # 返回字典dic的副本只复制一层浅拷贝)
dic.update(dic1) # 将字典dic1合并到dic中如果键相同则此键的值取dic1的值作为新值
dic.get(key, default) # 返回键key所对应的值如果没有此键则返回default
dic.keys() # 返回可迭代的dict_keys集合对象
dic.values() # 返回可迭代的dict_values值对象
dic.items() # 返回可迭代的dict_items对象
cmp(dict1, dict2) # 比较两个字典元素
len(dict) # 计算字典元素个数即键的总数
str(dict) # 输出字典可打印的字符串表示
type(variable) # 返回输入的变量类型如果变量是字典就返回字典类型参考https://blog.csdn.net/weixin_45014379/article/details/125641819
3.1. 创建
# 创建空字典
d {} # 空字典
d dict() # 空字典
# 创建非空的字典
dic1 {name: cgk, age: 20, sex: male}
dic2 dict(((name, cgk),))3.2. 查询
dic4 {name: cgk, age: 20, hobby: girl}
# 通过键查找
print(dic4[name], type(dic4[name])) # cgk class str
# 打印全部值
print(dic4.values(), type(dic4.values())) # dict_values([cgk, 20, girl]) class dict_values
# 打印全部键
print(dic4.keys(), type(dic4.keys())) # dict_keys([name, age, hobby]) class dict_keys
# 打印全部键值对
print(dic4.items(), type(dic4.items())) # dict_items([(name, cgk), (age, 20), (hobby, girl)]) class dict_items
# 打印全部键转成列表形式
print(list(dic4.keys()), type(list(dic4.keys()))) # [name, age, hobby] class list3.3. 增加
#增
dic1 {name: cgk}
dic1[age] 20
print(dic1)#键存在不改动返回字典中相对应的键对应的值
a dic1.setdefault(age, 30)
print(a)
print(dic1)#键不存在在字典中增加新的键值对并返回相应的值
b dic1.setdefault(hobby, girl)
print(b)
print(dic1)3.4. 修改
# 修改字典对应键的值
dic4 {name: cgk, age: 20, hobby: girl}
dic4[age] 30 #更新
dic4[school] 北大 #添加
print(dic4)# 向字典添加新内容的方法是增加新的键/值对——updat
dic4 {name: cgk, age: 20, hobby: girl}
dic5 {1: 1, age: 30}
dic4.update(dic5) #把dic5加进dic4里面如果有重复的键则覆盖
print(dic4)3.5. 删除
dic5 {name: cgk, age: 20, hobby: girl, school: 北大}
del dic5[name] #删除键是name的条目
print(dic5)red dic5.pop(hobby) #通过pop删除键是hoppy的条目并返回删除的值
print(red)
print(dic5)dic5.clear() #清空字典
print(dic5)del dic5 #直接删除字典3.6. 其他操作
# d.copy()
# 对字典 d 进行浅复制返回一个和d有相同键值对的新字典# 嵌套
#嵌套
av_catalog {欧美: {www.111.com: [免费的,高清的, 质量一般],www.222.com: [免费的,清晰, 质量还行],333.com: [自拍,图片, 资源不多,更新慢],444.com: [质量很高,good, 收费,白嫖绕路]},日韩: {555.com: [质量很差,不喜欢, 收费]},大陆: {666.com: [免费,好人一生平安, 服务器在国外,慢]}
}av_catalog[大陆][666.com][1] ,可以用爬虫爬下来 #修改
print(av_catalog[大陆][666.com]) #[全部免费,真好,好人一生平安, 服务器在国外,慢,可以用爬虫爬下来]# sorted(dict)
#返回一个有序的包含字典所有key的列表
dic {5: 555, 2: 222, 4: 444}
print(sorted(dic)) #默认根据键排序 [2, 4, 5]
print(sorted(dic.values())) #根据值排序 [222, 444, 555]
print(sorted(dic.items())) #根据键排序 [(2, 222), (4, 444), (5, 555)]# 字典的遍历
dic {zhangsan: {age: 11, sex: 男},李四: {age: 22, sex: 男},wangwu: {age: 33, sex: 女}}
#方法一
for i in dic:print(i) #默认遍历打印键print(i, dic[i]) #打印键值对#方法二
for i in dic.items():print(i) #打印键值对for i, v in dic.items():print(i, v) #打印键值对
4. 集合(set)
4.1. 创建
4.2. 查询
4.3. 增加
4.4. 修改
4.5. 删除
