Python_数据类型的补充、集合set、深浅copy
1、数据类型的补充
1、1 元组
当元组里面只有一个元素且没有逗号时,则该数据的数据类型与括号里面的元素相同。
tu1 = ('laonanhai')
tu2 = ('laonanhai')
print(tu1, type(tu1))
print(tu2, type(tu2),)
tu1 = (1)
tu2 = (1,)
print(tu1, type(tu1))
print(tu2, type(tu2))
tu1 = ([1, 2, 3])
tu2 = ([1, 2, 3],)
print(tu1, type(tu1))
print(tu2, type(tu2))
1、2 list 列表
在循环一个列表时,最好不要改变列表的大小,会影响你的最终结果。
li = [111, 222, 333, 444, 555,],索引为奇数的所有元素全部删除。
方法一:
l1 = [111, 222, 333, 444, 555, ]
del l1[1::2]
print(l1)
方法二(错误展示):
l1 = [111, 222, 333, 444, 555, ]
for index in range(len(l1)):
print('删除之前的index:%s' % index)
print('删除之前的l1:%s' % l1)
if index % 2 == 1:
del l1[index]
print('删除之后的index:%s' % index)
print('删除之后的l1:%s' % l1)
print(l1)
方法三(倒着删):
l1 = [111, 222, 333, 444, 555, ]
for index in range(len(l1) - 1, -1, -1):
if index % 2 == 1:
del l1[index]
print(l1)
方法四(自己做的):
l1 = [111, 222, 333, 444, 555, 666, 777, 888, 999, ]
i = len(l1)
count = 1
s = int(len(l1)/2)
for j in range(s):
del l1[count]
count += 1
print(l1)
1、3 字典
1、3、1 dict.fromkeys(A, B) A为可迭代对象,B任意。创建一个字典,迭代A的最小元素为键,B为值。
dic = dict.fromkeys('abc', 666)
print(dic)
dic = dict.fromkeys([11, 22, 33], 666)
print(dic)
dic = dict.fromkeys([1, 2, 3], [])
dic[1].append(666)
print(dic)
1、3、2 在循环字典时,最好不要改变字典的大小,会影响结果或者报错。
错误示例:
dic = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'name': 'alex'}
for i in dic:
if 'k' in i:
del dic[i]
print(dic)
dic = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'name': 'alex'}
l1 = []
for key in dic:
if 'k' in key:
l1.append(key)
print(l1)
for key in l1:
del dic[key]
print(dic)
1、4 数据类型的转换
str ------> list:
split
list ----->str:
join
tuple ------> list:
tu1 = (1, 2, 3)
l1 = list(tu1)
print(l1)
list ------> tuple:
tu1 = (1, 2, 3)
l1 = list(tu1)
tu2 = tuple(l1)
print(tu2)
dic ------> list:
list(dic) 列表中只有key。
dic = {'k1': 'v1', 'k2': 'v2','k3': 'v3',}
l1 = list(dic)
print(l1)
print(list(dic.keys()))
print(list(dic.values()))
print(list(dic.items()))
0, '',[], {},() ------> bool都是False。
print(bool(0))
print(bool(''))
print(bool(()))
print(bool([]))
print(bool({}))
print(bool([0, 0, 0]))
2、set 集合
set1 = {1, 2, 3, 'abc', (1, 2, 3), True, }
print(set1)
2、1 去重
集合去重。
set2 = {11, 11, 11, 22}
print(set2)
列表的去重。
l1 = [11, 11, 22, 22, 33, 33, 33, 44]
l2 = list(set(l1))
l2.sort()
print(l2)
2、2 增
__.add('A') A为添加的内容,随机添加。
set1 = {'alex', 'WuSir', 'RiTiAn', 'egon', 'barry'}
set1.add('太白')
print(set1)
__.update('A') A为添加的可迭代内容,将A拆分为最小单元然后迭代添加。
set1 = {'alex', 'WuSir', 'RiTiAn', 'egon', 'barry'}
set1.update('abc')
print(set1)
set1 = {'alex', 'WuSir', 'RiTiAn', 'egon', 'barry'}
set1.update([111, 2222, 333])
print(set1)
2、3 删
__.remove('A') 按元素删除。A为需要删除的内容。
set1 = {'alex', 'WuSir', 'RiTiAn', 'egon', 'barry'}
set1.remove('RiTiAn')
print(set1)
__.pop() 随机删除,有返回值。
set1 = {'alex', 'WuSir', 'RiTiAn', 'egon', 'barry'}
print(set1.pop())
print(set1)
__.clear() 清空集合。 空集合为set()。
set1 = {'alex', 'WuSir', 'RiTiAn', 'egon', 'barry'}
set1.clear()
print(set1)
del __ 删除集合。
set1 = {'alex', 'WuSir', 'RiTiAn', 'egon', 'barry'}
del set1
print(set1)
2、4 查
for循环。
set1 = {'alex', 'WuSir', 'RiTiAn', 'egon', 'barry'}
for i in set1:
print(i)
2、5 交集
交集:__ & __ 或者 __.intersection(__)
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1 & set2
print(set3)
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1.intersection(set2)
print(set3)
2、6 并集
并集:__ | __ 或者 __.union(__)
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1 | set2
print(set3)
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1.union(set2)
print(set3)
2、7 差集
差集:__ - __ 或者 __.difference(__)
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1 - set2
print(set3) # set1独有的
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1.difference(set2) # set1独有的
print(set3)
2、8 反交集
反交集:__ ^ __ 或者 __.symmetric_difference(__)
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1 ^ set2
print(set3)
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1.symmetric_difference(set2)
print(set3)
2、9 子集
子集:__ < __ 或者 __.issubset(__)
set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5, 6}
print(set1 < set2) # True set1 是set2 的子集
set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5, 6}
print(set1.issubset(set2)) # True set1是set2的子集
2、10 超集
set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5, 6}
print(set2 > set1) # set2 是 set1 的超集
set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5, 6}
print(set2.issuperset(set1)) # set2 是 set1 的超集
frozenset() frozenset是冻结的集合,它是不可变的,存在哈希值,好处是它可以作为字典的key,也可以作为其它集合的元素。缺点是一旦创建便不能更改,没有add,remove方法。
set1 = frozenset({1, 2, 3, 'alex'})
print(set1)
3、深浅copy
对于赋值运算来说,指向的都是同一个内存地址,一变都变。
l1 = [1, 2, 3]
l2 = l1
l3 = l2
l3.append(666)
print(l1, l2, l3)
3、1 浅copy
copy.() 浅copy
l1 = [11, 22, 33]
l2 = l1.copy()
l1.append(666)
print(l1, id(l1))
print(l2, id(l2))
当列表内层列表增加元素时,浅copy跟随变化。内层的列表同样是同一个地址。
对于浅copy来说,第一层创建的是新的内存地址,从第二层开始,指向的都是同一个内存地址,所以,对于第二层以及更深的层数来说,保持一致性。
l1 = [11, 22, ['barry', [55, 66]], [11, 22]]
l2 = l1.copy()
l1[2].append('alex')
print(l1, id(l1))
print(l2, id(l2))
print(l1, id(l1[-1]))
print(l2, id(l2[-1]))
3、2 深copy
import copy
import copy
l1 = [11, 22, 33]
l2 = copy.deepcopy(l1)
l1.append(666)
print(l1, id(l1))
print(l2, id(l2))
import copy
l1 = [11, 22, ['barry']]
l2 = copy.deepcopy(l1)
l1[2].append('alex')
print(l1, id(l1[-1]))
print(l2, id(l2[-1]))
深copy 完全独立。
l1 = [1, 2, 3]
l2 = [1, 2, 3]
l1.append(666)
print(l1, id(l1))
print(l2, id(l2))
对于切片来说,这是浅copy。
l1 = [1, 2, 3, 4, 5, 6, [11, 22]]
l2 = l1[:]
l1.append(666)
print(l1, l2)
l1 = [1, 2, 3, 4, 5, 6, [11, 22]]
l2 = l1[:]
l1[-1].append(666)
print(l1, l2)
Python_数据类型的补充、集合set、深浅copy的更多相关文章
- python基础之数据类型操作补充,集合及其操作,深浅拷贝
内容概要: 数据类型操作补充 集合及其操作 深浅拷贝1.基础数据类型补充 1.1字符串的操作补充li = ["李嘉诚", "麻花藤", "黄海峰&qu ...
- python之数据类型补充、集合、深浅copy
一.内容回顾 代码块: 一个函数,一个模块,一个类,一个文件,交互模式下,每一行就是一个代码块. is == id id()查询对象的内存地址 == 比较的是两边的数值. is 比较的是两边的内存地址 ...
- python 的基础 学习 第八天数据类型的补充 ,集合和深浅copy
1,数据类型的补充: 元组()tuple,如果只有元素,并且没有逗号,此元素是什么数据类型,该表达式就是什么数据类型. tu = ('rwr') print(tu,type(tu)) tu = ('r ...
- 基础数据类型之集合和深浅copy,还有一些数据类型补充
集合 集合是无序的,不重复的数据集合,它里面的元素是可哈希的(不可变类型),但是集合本身是不可哈希(所以集合做不了字典的键)的.以下是集合最重要的两点: 去重,把一个列表变成集合,就自动去重了. 关系 ...
- day 07 数据类型,集合,深浅copy
1.day 06 内容回顾 小数据池 int :-5-256 str:特殊字符 ,*20 ascii:8位 1字节 表示一个字符 unicode:32位 4个字节 , 表示一个字符 字节表示8位表示一 ...
- python-基础数据类型,集合及深浅copy
一 数据类型定义及分类 我们人类可以很容易的分清数字与字符的区别,但是计算机并不能呀,计算机虽然很强大,但从某种角度上看又很傻,除非你明确的告诉它,1是数字,“汉”是文字,否则它是分不清1和‘汉’的区 ...
- 基础数据类型的坑和集合及深浅copy
一.基础数据类型的坑: 元组: 如果一个元组中,只有一个元素,且没有逗号,则该"元组"与里面的数据的类型相同. # 只有一个数据,且没有逗号的情况: print(tu1,type( ...
- 07、python的基础-->数据类型、集合、深浅copy
一.数据类型 1.列表 lis = [11, 22, 33, 44, 55] for i in range(len(lis)): print(i) # i = 0 i = 1 i = 2 del li ...
- 数据结构中的列表、元组、字典、集合 ,深浅copy
数据结构:数据结构是计算机存储数据和组织数据的方式.数据结构是指相互之间存在一种或多种特定关系的数据元素的集合.在python中主要的数据类型统称为容器. 而序列(如列表.元组).映射(如字典).集合 ...
随机推荐
- Python3中操作字符串str必须记住的几个方法
几个Python的字符串常用内建函数 1.方法:Python3 isdigit()方法 描述:Python isdigit() 方法检测字符串是否只由数字组成. 语法:str.isdigit() 参数 ...
- centos7 多网卡绑定bond0 之mod4
什么是mod4 mod=4,即:(802.3ad) IEEE 802.3ad Dynamic link aggregation(IEEE 802.3ad 动态链接聚合) 特点:创建一个聚合组,它们共享 ...
- AOP的底层实现:JDK动态代理与Cglib动态代理
转载自 https://www.cnblogs.com/ltfxy/p/9872870.html SpringAOP底层的实现原理: JDK动态代理:只能对实现了接口的类产生代理.(实现接口默认JDK ...
- 洛谷P1031
#include <iostream>#include <algorithm>#include <cstdio>using namespace std;int a[ ...
- Java 8 新特性:1-函数式接口
(原) Java 8 新特性1-函数式接口 Lambda表达式基本结构: (param1,param2,param3) -> {代码块} Lambda表达式结构: (type1 arg1,typ ...
- zabbix全网监控
为什么要监控 运维的职责1.保障企业数据的安全可靠.2.为客户提供7*24小时服务.3.不断提升用户的体验. 在关键时刻,提前提醒我们服务器要出问题了 当出问题之后,可以便于找到问题的根源 拿到公司服 ...
- centos7下升级SSH
Linux 发行版中集成的 SSH 软件版本都比较老,存在着一些漏洞和安全隐患,需要升级 SSH 服务软件修补漏洞提升系统安全. SSH:SSH 有许多标准,通常 Linux 中 ( Redhat, ...
- 转://Oracle 事务探索与实例(一)
一数据库版本 SYS@LEO1>select* from v$version; BANNER -------------------------------------------------- ...
- 【ECMAScript5】ECMAScript5中有关数组的常用方法
1.indexOf() 此方法返回在改数组中第一个找到的元素位置,如果它不存在则返回-1 var arr = ['apple','orange','pear']; console.log(" ...
- Bean named '*' must be of type [*], but was actually of type []
本地Service 名字和调用别的maven项目Service重名