Python装数据的盒子

一.列表(list)

创建列表

1.创建列表--手动创建

a=[1,2,3,4,5,6]

2.列表推导式

a=[i*x for i ina]

i*x是被循环

表达方式

a=[表达式for变量可迭代]

x=[表达式for变量range if ]

if是筛选

3.建立二维数组

(1).直接创建

a=[[0,0,0],[0,0,0],[0,0,0]]

b=[[0,0,0]

[0,0,0]

[0,0,0]]

a=b

(2).使用for循环

a=[0]*3
for iinrange(3):
a[i]=[0]*3

(3).a=[[0]*3foriinrange(3)]

5.将二维转换为一维

a=[[0,0,0],[0,0,0],[0,0,0]]

b=[xforiinaforxiny]

6.使用list()

a=1,2,3,4,5,6,7,8,9
b=list(a)
print(b)
执行结果>>[1,2,3,4,5,6,7,8,9]

7.拼接

列表的操作

切片

a[开始位置：结束位置:步长]

结束位置的索引对象切不到

倒取必须要设置步长

开始正结束负步长为正

开始负结束正步长为负

1.append()添加元素到列表中(添加的数据类型不变)

2.extend()添加列表到列表，用于扩增列表

3.insert()插入元素，两个参数，第一个，指定索引，第二个，待插入的元素

4.remove()指定一个元素删除

5.pop()索引一个元素删除，如果不带参数会删除最后一个元素

6.clear()清空列表里的元素

7.del删除（永久删除）

del与其他方法的区别----其他方法是删除列表里的元素，del是删除整个列表其他方法删除完最终得到空列表，del

是永久删除列表

8.reverse()原地反转列表元素

9.sort(reverse=False)从小到大排序，当参数reverse=Ture从大到小排序

10.count()某个元素在列表中出现的次数

11.index()返回列表中某个元素第一次出现的索引值

12.copy()拷贝(浅)

13deepcopy()拷贝(深)

a=[1,2,3,4,5,6,7,8,9]

b=["齐"，"喾"]

c=[22,16,12,11,56,78,123,56,89,43]

d=[1,22,1,45,22,33,77,77,77,88,77]

a.append(10086)

执行结果>>[1,2,3,4,5,6,7,8,9,10086]

a.append("喾")

执行结果>>[1,2,3,4,5,6,7,8,9,'喾']

a.extend(b)

执行结果>>[1,2,3,4,5,6,7,8,9,'齐','喾']

a.insert(1,"执着")

执行结果>>[1,'执着',2,3,4,5,6,7,8,9]

a.remove(9)

执行结果>>[1,2,3,4,5,6,7,8]

a.pop(0)

执行结果>>[2,3,4,5,6,7,8,9]

a.pop()

执行结果>>[1,2,3,4,5,6,7,8]

a.clear()

执行结果>>[]

dela

执行结果

print(a)

^

NameError:name'a'isnotdefined

c.reverse()

执行结果>>[43,89,56,123,78,56,11,12,16,22]

c.sort()

执行结果>>[11,12,16,22,43,56,56,78,89,123]

c.sort(reverse=True)

执行结果>>[123,89,78,56,56,43,22,16,12,11]

jmh=d.count(77)

print(jmh)

执行结果>>4

jmh=d.index(77)

print(jmh)

执行结果>>6

二.元组(tuple)

列表用方括号，元组用圆括号，nonono,元组可以用圆括号也可以不用圆括号,逗号才是关键

a=(1,2,3,4)
print(type(a))
b=1,2,3,4
print(type(b))
c=1
print(typt(c))
d=1,
print((d))
执行结果>>
class<tuple>
class<tuple>
class<int>
class<tuple>

浅拷贝和深拷贝

a=[1,2,3]
b=a#这个不是拷贝，只能说是两者指向了相同的内存地址
b=a.copy()#浅拷贝
id(a)
>>2975503204288
id(b)
>>2975503401792
print(id(a[0]),id(a[1]),id(a[2]))
>>140724536337192140724536337224140724536337256
print(id(b[0]),id(b[1]),id(b[2]))
>>140724536337192140724536337224140724536337256
#可见浅拷贝只是拷贝了部分内存数据
a[2]=1
a
>>[1,2,1]
b
>>[1,2,3]
print(id(a[0]),id(a[1]),id(a[2]))
>>140724536337192140724536337224140724536337192
print(id(b[0]),id(b[1]),id(b[2]))
>>140724536337192140724536337224140724536337256
importcopy#拷贝模块
a=[1,2,3]
b=copy.copy(a)#浅拷贝和上面一样
a
>>[1,2,3]
b
>>[1,2,3]
print(id(a[0]),id(a[1]),id(a[2]))
>>140724536337192140724536337224140724536337256
print(id(b[0]),id(b[1]),id(b[2]))
>>140724536337192140724536337224140724536337256
a[2]=10
a
>>[1,2,10]
b
>>[1,2,3]
print(id(a[0]),id(a[1]),id(a[2]))
>>140724536337192140724536337224140724536337480
print(id(b[0]),id(b[1]),id(b[2]))
>>140724536337192140724536337224140724536337256

a=[[1,2,3],[4,5,6],[7,8,9]]

b=copy.copy(a)

a

>>[[1,2,3],[4,5,6],[7,8,9]]

b

>>[[1,2,3],[4,5,6],[7,8,9]]

aisb

>>True

a==b

>>True

a[1][1]

>>5

a[1][1]=0

a

>>[[1,2,3],[4,0,6],[7,8,9]]

b

>>[[1,2,3],[4,0,6],[7,8,9]]

a=[[1,2,3],[4,5,6],[7,8,9]]

b=copy.deepcopy(a)

print(id(a[0]),id(a[1]),id(a[2]))

>>297550333977629755034003842975495572864

print(id(b[0]),id(b[1]),id(b[2]))

>>297550320140829755034032002975503403456

aisb

>>False

a==b

>>True

a[1][1]

>>5

a[1][1]=0

>>a

[[1,2,3],[4,0,6],[7,8,9]]

>>b

[[1,2,3],[4,5,6],[7,8,9]]

创建元组

a=[1,2,3,4,5]

b=tuple(a)

peint(type(b))

执行结果>>class<tuple>

#复制元组用切片

a=1,2,3,4,5,6

b=a[:3]

print(b)

执行结果>>(1,2,3)

c=a+b#元组拼接

print(c)

元组是不能被修改的

a=1,2,3,4,5
b[0]="ch"
print(a)
执行结果>>TypeError:'tuple'objectdoesnotsupportitemassignment
#修改元组
a=1,2,3,4,5

print(id(a))
a=(a[0],"ch")+a[3:]
print(a)
print(id(a))
执行结果>>1619694551264
(1,"ch",3,4,5)
1619694562704
#id不一样
#其原理是元组的拼接

"""
列表和元组的相同和异同：
1.列表和元组都属于序列，而列表属于可变序列，元组是非可变序列，其中元素不可以修改，除非更换整体
2.列表可以使用方法实现添加修改等操作，因为元组不能添加和修改元素，同样也不能删除元素
3.列表和元组都支持切片操作，列表可以通过切片修改，但是元组只可以通过切片访问
4.元组比列表的访问和处理方法块，所以如果只需要对其中的元素进行访问，不进行任何操作，建议使用元组
"""

三.字典(dict)

创建字典

a=dict(zip(list1,list2))

list1=[1,2,3,4,5]#字典的键

list2=[6,7,8,9,0]#字典的值

a=dict(zip(list1,list2))

print(a)

执行结果>>{1:6,2:7,3:8,4:9,5:0}

#键值对一一对应，两者的元素要相同

Z=dict((('1',70),('2',90),('3',90)))

print(Z)

执行结果>>{'1':70,'2':90,'3':90}

a=dict(a=1,b=2,c=3,d=4)

print(a)

执行结果>>{'a':1,'b':2,'c':3,'d':4}

fromkey(seq,[value])创建字典seq为字典的键，value为字典元素,当value参数不选时则返回一个只有键的列表

dict1={}
print(dict1.fromkeys((1,2,3,4,5),('one','two','tree','four','five')))
执行结果>>{1:('one','two','tree','four','five'),2:('one','two','tree','four','five'),
3:('one','two','tree','four','five'),4:('one','two','tree','four','five'),5:('one',
'two','tree','four','five')}

keys()返回字典的键，values(),返回字典的值，items()返回函数的键值对(项)

如果项不存在访问会报错

a.get(key,[defaule])

key表示键，defaule代表的是当没有项时返回的提示

clear()用于清空列表

赋值清空的字典，数据会指向被赋值的变量不会清除数据

copy()，用于拷贝(浅)整个列表

pop()指定键弹出对应值

popittem()弹出项

setdefaule()与get方法差不多，在没有键时setdefaule(),会在字典后面添加这个键

四.字符串

1.格式化：字符串格式化format()

"我{0}学习{1}".format("喜欢","python")

'我喜欢学习python'

"我{}学习{}".format("喜欢","python")

'我喜欢学习python'

"我{{}}学习{}".format("喜欢","python")

'我{}学习喜欢'

#将大括号注释

2.格式化操作符

%c------ASCII码

%s------字符串

%d------整数

%o------无符号八进制

%x------无符号十六进制

%X------无符号十六进制(大写)

%f------浮点数，可指定精度

%e------科学计数法格式化浮点数

%E------与%e相同

%g------根据只的大小决定使用%f还是%e

%G------与%g一样

3.转义字符

/'------单引号

/''------双引号

\a------发出系统响铃声

\b------退格符

\n------换行符

\t------横向制表符

\v------纵向制表符

\r------回车符

\f------换页符

\o------八进制数代表的字符

\x------十六进制数代表的字符

\0------表示一个空字符

\\------反斜杠

五·集合
没有体现映射关系的字典就是集合

a={1,2,3,4,5}
type(a)
<class'set'>

集合的创建
1.使用set()函数
2.大括号直接创建
访问集合
由于集合是无序的无法使用下标索引
访问集合使用迭代即可

a={1，2，3，4}
foriina:
print(i,end="")
>>1234

当然可以使用innotin判断一个元素是否在集合里
使用add()可以为集合添加元素，使用remove()可以删除已知的元素

a=frozenset({1,2,3,4,5})
a.add(6)
Traceback(mostrecentcalllast):
File"<pyshell#2>",line1,in<module>
a.add(6)
AttributeError:'frozenset'objecthasnoattribute'add'

六.序列

list()用于把一个可迭代对象转换成一个列表

tuple()用于把一个可迭代对象转换成一个元组

max()返回序列中的最大值

min()返回序列中的最小值

sun(iterable,(,start))返回序列中所有元素的和start表示从多少开始加起默认为0

sorted(iterable,key=None,reverse=False)默认为从小到大排列当reverse=Ture为从大到小排列sorted返回一个有大小关

系的新序列

reversed()返回一个逆向迭代序列，与reverse效果一致但区别在于此方法返回一个迭代器对象

a=[1,2,3,4]
a.reverse()
a
[4,3,2,1]
reversed(a)
<list_reverseiteratorobjectat0x0000024F34FDF940>
foriinreversed(a):
print(a)
[4,3,2,1]
[4,3,2,1]
[4,3,2,1]
[4,3,2,1]

enumerate()生成由二元组构成的迭代对象，每个二元组由可迭代的索引号以及对应的元素组成

a="changhao"
foriinenumerate(a):
print(i)
(0,'c')
(1,'h')
(2,'a')
(3,'n')
(4,'g')
(5,'h')
(6,'a')
(7,'o')

zip()返回由各个可迭代参数共同组成的元组

a=[1,2,3,4,5]
b=[6,7,8,9,0]
foriinzip(a,b):
print(i)
(1,6)
(2,7)
(3,8)
(4,9)
(5,0)
c="齐喾"
foriinzip(a,b,c):

print(i)
(1,6,'齐')
(2,7,'喾')