十年网站开发经验 + 多家企业客户 + 靠谱的建站团队
量身定制 + 运营维护+专业推广+无忧售后,网站问题一站解决
列表在python里是有序集合对象类型。
列表里的对象可以是任何对象:数字,字符串,列表或者字典,元组。与字符串不同,列表是可变对象,支持原处修改的操作
python的列表是:
列表的操作和字符串大部分都相同:
合并/重复:
创建一个列表:
>>> list=[]
>>> list=[1,2,'3',[]]
>>> list
[1, 2, '3', []]
列表取值:
>>> list[1]
2
>>> list[0:3]
[1, 2, '3']
重复列表内容:
>>> list*3
[1, 2, '3', [], 1, 2, '3', [], 1, 2, '3', []]
使用in方法来判断对象是否在列表中:
>>> 3 in list
False
>>> [] in list
True
循环打印:
>>> for i in list:
... print (i,end=' ')
...
1 2 3 []
迭代方式创建列表:
>>> list=[i*4 for i in 'ASDF' ]
>>> list
['AAAA', 'SSSS', 'DDDD', 'FFFF']
矩阵:
list=[ [1,2,3,],[4,5,6],[7,8,9] ]
>>> list
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> list[0][1]
2
>>> list[1][2]
6
列表原处修改:
>>> food=['spam','eggs','milk']
>>> food[1]
'eggs'
>>> food[1]='Eggs'
>>> food[:]
['spam', 'Eggs', 'milk']
>>>food.append('cake')
>>> food
['spam', 'Eggs', 'milk', 'cake']
>>> food.sort()
>>> food
['Eggs', 'cake', 'milk', 'spam']
>>> list1=[1,2,3]
>>> list2=[4,5,6]
>>> list1.extend(list2)
>>> list1
[1, 2, 3, 4, 5, 6]
>>> list1.pop()
6
>>> list1
[1, 2, 3, 4, 5]
>>> list1
[1, 2, 3, 4, 5]
>>> list1.reverse()
>>> list1
[5, 4, 3, 2, 1]
>>> list=[1,2,3,4,5]
>>> list.index(3)
2
>>> list.insert(2,10)
>>> list
[1, 2, 10, 3, 4, 5]
>>> list
[1, 2, 10, 3, 4, 5]
>>> del list[2]
>>> list
[1, 2, 3, 4, 5]
>>> list=['abc','aDd','ace']
>>> sorted(list)
['aDd', 'abc', 'ace']
>>> list
['abc', 'aDd', 'ace']
>>> sorted(list,key=str.lower,reverse=True)
['aDd', 'ace', 'abc']
>>> sorted(list,key=str.lower)
['abc', 'ace', 'aDd']
>>>sorted([x.lower() for x in list])
['abc', 'ace', 'add']
>>> sorted([x.lower() for x in list],reverse=True)
['add', 'ace', 'abc']
>>> info=['myname',18,[1997,9,28]]
>>> _name,_age,_birth=info
>>> _name
'myname'
>>> _age
18
>>> _birth
[1997, 9, 28]
>>> _name,_age,(_birth_y,_birth_m,_birth_d)=info
>>> _birth_y
1997
>>> _birth_m,_birth_d
(9, 28)
当取的值不固定的时候,可以用*代替:
>>> a=['adc',122,2215,'asd@asd']
>>> a_name,*a_phone,a_mail=a
>>> a_name
'adc'
>>> a_phone
[122, 2215]
>>> from collections import deque
>>> q=deque(maxlen=3)
>>> q.append(1)
>>> q.append(2)
>>> q.append(3)
>>> q
deque([1, 2, 3], maxlen=3)
>>> q.append(4)
>>> q
deque([2, 3, 4], maxlen=3)
>>> q.appendleft('5')
>>> q
deque(['5', 2, 3], maxlen=3)
>>> from heapq import nlargest,nsmallest
>>> num=[1,4,6,7,8,8,34,64,23,7,45,34]
>>> nlargest(3,num)
[64, 45, 34]
>>> nlargest(2,num)
[64, 45]
>>> nsmallest(2,num)
[1, 4]
>>> nsmallest(4,num)
[1, 4, 6, 7]
>>> num
[1, 4, 6, 7, 8, 8, 34, 64, 23, 7, 45, 34]
>>> max(num)
64
>>> min(num)
1
>>> sum(num)
241
>>> a_info=['wanger','wangerxiao',25,'computer']
>>> _name=slice(0,2)
>>> _age=slice(2,3)
>>> _job=slice(3,4)
>>> a_info[_name]
['wanger', 'wangerxiao']
>>> a_info[_age]
[25]
>>> a_info[_job]
['computer']
>> a=[1,2,3,4,5,6,2,4,2,5,6]
>>> from collections import Counter
>>> count_word=Counter(a)
>>> count_word
Counter({2: 3, 4: 2, 5: 2, 6: 2, 1: 1, 3: 1})
>>> count_word.most_common(3)
[(2, 3), (4, 2), (5, 2)]
>>> count_word.most_common(2)
[(2, 3), (4, 2)]
字典在python里是无序集合对象类型。
字典的值都有独立的唯一的键,用相应的键来取值。
python字典主要特性如下:
字典用法注意事项:
字典的赋值:
>>> dict={'a':97,'b':98}
>>> len(dict)
2
>>> print("ascii code of 'a' is {},ascii code of 'b' is {}".format(dict['a'],dict['b']))
ascii code of 'a' is 97,ascii code of 'b' is 98
判断特定的键是否存在于字典里:
>>> 'a' in dict
True
>>> 'b
>>>> 'b' is in dict
True
#更改特定键的值
>>> food={'eggs':3,'ham':1,'spam':4}
>>> food['ham']=2
>>> food
{'eggs': 3, 'ham': 2, 'spam': 4}
#增加新的键和相应的值
>>> food['branch']=['bacon','bake']
>>> food
{'eggs': 3, 'ham': 2, 'spam': 4, 'branch': ['bacon', 'bake']}
#删除一个字典元素
>>> del food['eggs']
>>> food
{'ham': 2, 'spam': 4, 'branch': ['bacon', 'bake']}
#清空字典所有条目
>>> dict.clear()
#删除字典
del dict
查找字典的键值是否存在,如果不存在可以设置返回的值
>>> food.get('ham')
2
>>> dict.get('b')
2
>>> dict.get('0')
>>> dict.get('0','none')
'none'
创建字典的方法:
1.最原始的方法:
dict={'name':'wanger','age':25}
2.按键赋值方法:
>>> dict={}
>>> dict['name']='wanger'
>>> dict['age']=25
字典的比较:
字典的比较会比较字典的键,而不是字典的值,可以使用zip方式将字典的值和键反过来,这样就会比较值了,可以使用sorted函数对字典进行排序
>>> dict={'a':1,'b':2,'c':3,'d':4}
>>> max(dict)
'd'
>>> min(dict)
'a'
>>> max(zip(dict.values(),dict.keys()))
(4, 'd')
>>> min(zip(dict.values(),dict.keys()))
(1, 'a')
>>> sorted(zip(dict.values(),dict.keys()))
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]
>>> sorted(zip(dict.values(),dict.keys()),reverse=True)
[(4, 'd'), (3, 'c'), (2, 'b'), (1, 'a')]
>>> rows
[{'fname': 'Brian', 'lname': 'Jones', 'uid': 1003},
{'fname': 'David', 'lname': 'Beazley', 'uid': 1002},
{'fname': 'John', 'lname': 'Clesse', 'uid': 1001},
{'fname': 'Big', 'lname': 'Jones', 'uid': 1004}]
>>> from operator import itemgetter
>>> rows_fname=sorted(rows,key=itemgetter('fname'))
>>> rows_fname
[{'fname': 'Big', 'lname': 'Jones', 'uid': 1004},
{'fname': 'Brian', 'lname':
'Jones', 'uid': 1003},
{'fname': 'David', 'lname': 'Beazley', 'uid': 1002},
{'fname': 'John', 'lname': 'Clesse', 'uid': 1001}]
>>> rows_uid=sorted(rows,key=itemgetter('uid'))
>>> rows_uid
[{'fname': 'John', 'lname': 'Clesse', 'uid': 1001},
{'fname': 'David', 'lname': 'Beazley', 'uid': 1002},
{'fname': 'Brian', 'lname': 'Jones', 'uid': 1003},
{'fname': 'Big', 'lname': 'Jones', 'uid': 1004}]
元组与列表非常类似,只是不能在原处更改,元祖在python里的特点:
元祖创建在只有单个元素的时候,必须加逗号(,),元组里可以嵌套元组
>>> tuple=()
>>> tuple=(1,)
>>> type(tuple)
#这里加不加括号都一样
>>> tuple=(1,2,'3',(4,5))
>>> tuple
(1, 2, '3', (4, 5))
>>> tuple=1,2,'3',(4,5)
>>> tuple
(1, 2, '3', (4, 5))
>>> list=[1,2,3,4]
>>> sd=tuple(list)
>>> sd
(1, 2, 3, 4)
元组的排序:
元组经过sorted排序后,会将其转换为列表
>>> tuple=(1,5,3,6,4,2)
>>> sorted(tuple)
[1, 2, 3, 4, 5, 6]
>>> tuple
(1, 5, 3, 6, 4, 2)
>>> tuple.index(3)
2
计算元组元素数目:
>>> tuple
(1, 5, 3, 6, 4, 2)
>>> tuple.count(3)
1
元组的切片:
>>> tuple[0]
1
>>> tuple[2:]
(3, 6, 4, 2)
>>> tuple[2:3]
(3,)
>>> (1,2)+(3,4)
(1, 2, 3, 4)
>>> (1,2)*4
(1, 2, 1, 2, 1, 2, 1, 2)
>>> len(tuple)
6
set是一个无序且不重复的元素集合
集合对象十一组无序排列的可哈希的值,集合成员可以做字典中的键。set也支持用in 和not in操作符检查成员,由于集合本身是无序的,不可以为集合创建索引或执行切片操作,也没有键可用来获取集合中元素的值。
>>> s=set('a')
>>> a=set({'k1':1,'k2':2})
>>> b=(['y','e','d','o'])
>>> c={'a','b','c'}
>>> d={('a','b','c')}
#比较a、b集合中a中存在,b中不存在的集合
>>> a={11,22,33}
>>> b={11,23,45}
>>> a.difference(b)
{33, 22}
#找到a中存在,b中不存在的集合,并把a、b集合中都有的值覆盖掉
>>> a={11,22,33}
>>> print(a.difference_update(b))
None
>>> a
{33, 22}
集合的删除:
>>> a={11,22,33}
>>> a.discard(11)
>>> a.discard(44)
>>> a
{33, 22}
#移除不存在的元素会报错
>>> a={11,22,33}
>>> a.remove(11)
>>> a.remove(44)
Traceback (most recent call last):
File "", line 1, in
KeyError: 44
>>> a
{33, 22}
#移除末尾的元素
>>> a={11,22,33}
>>> a.pop()
33
>>> a
{11, 22}
取交集:
#取交集赋给新值
>>> a={1,2,3,4}
>>> b={6,5,4,3}
>>> print (a.intersection(b))
{3, 4}
#取交集并把交集赋给a
>>> print (a.intersection_update(b))
None
>>> a
{3, 4}
>>> a={3,4}
>>> b={6,5,4,3}
#判断a是否与b没有交集,有交集False,无交集True
>>> a.isdisjoint(b)
False
#判断a是否是b的子集
>>> a.issubset(b)
True
#判断a是否是b的父集
>>> a.issuperset(b)
False
>>> a={1,2,3,4}
>>> b={3, 4, 5, 6}
#打印不同的元素
>>> print (a.symmetric_difference(b))
{1, 2, 5, 6}
#打印不同的元素,并覆盖到集合a
>>> print (a.symmetric_difference_update(b))
None
>>> a
{1, 2, 5, 6}
>>> a={1, 2, 5, 6}
>>> b={3, 4, 5, 6}
>>> print (a.union(b))
{1, 2, 3, 4, 5, 6}
集合的更新:
>>> a={1, 2, 5, 6}
>>> b={3, 4, 5, 6}
#把a、b的值合并,并把值赋给集合a
>>> a.update(b)
>>> a
{1, 2, 3, 4, 5, 6}
#添加a集合的元素
>>> a.update([7,8])
>>> a
{1, 2, 3, 4, 5, 6, 7, 8}
>>> a=set(range(5))
}
>>> li=list(a)
>>> tu=tuple(a)
>>> st=str(a)
>>> print (li)
[0, 1, 2, 3, 4]
>>> print (tu)
(0, 1, 2, 3, 4)
>>> print (st)
{0, 1, 2, 3, 4}
文件对象在python里可以作为操作系统上的文件的链接
文件对象的使用方式与之前的字符串、列表等对象不同,它是对文件的输入、输出进行控制
在python里会用open函数来进行文件的控制
在python里使用open函数可以访问文件。
基本格式是:open(
这里的文件地址是文本形式,在Windows里由于文件地址是使用反斜杠(),所以,可以使用r来对反斜杠不进行转义。
例如:
open(r'C:\mydir\myfile')
访问模式里是参数,默认是r(读取)
在访问模式,每一种方法都有一种使用到b的方式,就是二进制模式。
文件的读写参数
操作说明符 | 解释 |
---|---|
r | 以只读方式打开文件,这是默认模式 |
rb | 以二进制格式打开一个文件用于只读。这是默认模式 |
r+ | 打开一个文件用于读写 |
rb+ | 以二进制格式打开一个文件用于读写 |
w | 打开一个文件只用于写入。文件存在则覆盖,不存在,则创建新文件 |
wb | 以二进制格式打开一个文件只用于写入。文件存在则覆盖,不存在则创建 |
w+ | 打开一个文件用于读写。如果文件已存在则将其覆盖,不存在则创建新文件。 |
wb+ | 以二进制打开一个文件用于读写。如果该文件存在则覆盖,不存在则创建 |
a | 打开一个文件用于追加,如果文件内容存在,则将新内容追加到文件末尾,不存在则创建新文件写入 |
ab | 以二进制格式打开一个文件用于写入 |
a+ | 打开一个文件用于读写,如果该文件存在,则会将新的内容追加到文件末尾,如果文件不存在,则创建新文件用于读写。 |
ab+ | 以二进制格式打开一个文件用于追加,文件存在将追加,不存在则创建新文件用于读写 |
例子
>>> file1=open(r'D:\ruanjian\1.txt','w')
>>> file1.write('hello,world')
11
>>> file1.close()
>>> file1=open(r'D:\ruanjian\1.txt')
>>> file1.read()
'hello,world'
#tell用于获取文件指针位置,文件读取之后,文件指针在最后面
>>> file1.tell()
11
>>> file1.close()
>>>> file1=open(r'D:\ruanjian\1.txt')
>>> file1.seek(6)
6
>>> file1.read(5)
'world'
当我们要读取前五个字符的时候可以这样:
>>> file1=open(r'D:\ruanjian\1.txt')
>>> file1.read(5)
'hello'
>>> file1.tell()
5
当我们要按行读取的时候,可以使用readline和readlines方法
>>> file1=open(r'D:\ruanjian\1.txt')
>>> file1.readline()
'hello,world\n'
>>> file1.readline()
'wanger\n'
>>> file1.readline()
'asdfgghh'
>>> file1.readline()
''
>>> file1=open(r'D:\ruanjian\1.txt')
>>> file1.readlines()
['hello,world\n', 'wanger\n', 'asdfgghh']
当我们需要写入到一个文件的时候,会使用w模式。当相应的文件存在时,会覆盖原先的文件然后写入,当相应的文件不存在时会创建新文件。
基本写入
>>> file=open(r'D:\ruanjian\1.txt','w')
>>> file.write('hello,world')
11
>>> file.write('|wanger')
7
>>> file.flush()
>>> file.close()
>>> file=open(r'D:\ruanjian\1.txt')
>>> file.read()
'hello,world|wanger'
在这里flush()方法是把缓存里的内容写入硬盘中。当运行close()方法的时候,也会进行同样操作。
按列表写入:
writelines是把列表里的元素一个一个输入进去。当然,元素里的字符串最后没有换行,最终结果也不是换行的。
>>> list=['hello,world!\n','wanger\n','asdfgh\n']
>>> file=open(r'D:\ruanjian\1.txt','w')
>>> file.writelines(list)
>>> file.close()
>>> file=open(r'D:\ruanjian\1.txt')
>>> file.read()
'hello,world!\nwanger\nasdfgh\n'
在特定位置写入
当我们输入错误的时候,可以把指针挪到最前面,然后继续输入。seek可以有两个传递变量,只有一个变量或者第一个变量为0时,就是更改当前的指针,第二个变量为1的时候,会返回当前指针位置,这个与tell方法同样,最后,第一个变量为0,第二个变量为2的时候会把指针放到最后
>>> file=open(r'D:\ruanjian\1.txt','w')
>>> file.write('heelo')
5
>>> file.seek(0)
0
>>> file.write('hello')
5
>>> file=open(r'D:\ruanjian\1.txt')
>>> file.read()
'hello'
在最后写入
之前看到的w模式,当文件是已有文件,就会删除里面的所有内容后再写入的。当我们需要在最后添加,而不是删除原有内容时,可以使用a模式。
>>> file=open(r'D:\ruanjian\1.txt')
>>> file.read()
'hello'
>>> file.close()
>>> file=open(r'D:\ruanjian\1.txt','a')
>>> file.write('my name is wanger')
17
>>> file=open(r'D:\ruanjian\1.txt')
>>> file.read()
'hellomy name is wanger'
在模式里,我们会看到r+,w+,a+三种模式都有读写的方法。
r+模式,只能打开已有文件,打开时保留原有文件,对文件可读,可写,也可更改原有内容。打开是指针在文件最前面。
w+模式,打开时没有相应的文件,会创建;有相应的文件会覆盖原有的内容
a+模式,可以打开原有文件,也可创建新的文件,打开时指针为文件的最后位置。指针可以放到任何位置来读内容,但写入时,指针默认会移动到最后,然后写入。
模式 | 打开已有文件 | 打开新的文件 | 打开时指针位置 | 写入时指针位置 |
---|---|---|---|---|
r+ | 保留内容 | 发生错误 | 文件开头 | 当前位置 |
w+ | 删除内容 | 创建文件 | 文件开头 | 当前位置 |
a+ | 保留内容 | 创建文件 | 文件尾端 | 文件尾端 |
>>> cha='啊'
>>> cha_b=cha.encode()
>>> file=open(r'D:\ruanjian\1.txt','w')
>>> file.write(cha)
1
>>> file.write(cha_b)
Traceback (most recent call last):
File "", line 1, in
TypeError: write() argument must be str, not bytes
>>> file.close()
>>> file=open(r'D:\ruanjian\1.txt')
>>> file.read()
'啊'
>>> file=open(r'D:\ruanjian\1.txt','wb')
>>> file.write(cha)
Traceback (most recent call last):
File "", line 1, in
TypeError: a bytes-like object is required, not 'str'
>>> file.write(cha_b)
3
>>> file.close()
>>> file=open(r'D:\ruanjian\1.txt','rb')
>>> file.read()
b'\xe5\x95\x8a'
>>> file=open(r'D:\ruanjian\1.txt','w')
>>> file.write({'a':97})
Traceback (most recent call last):
File "", line 1, in
TypeError: write() argument must be str, not dict
>>> file.write(str({'a':97}))
9
>>> file.write(str([1,2]))
6
>>> file.close()
>>> file=open(r'D:\ruanjian\1.txt')
>>> file.read()
"{'a': 97}[1, 2]"
如果要将存储的字符串转换回原来的数据类型,可以用pickle模块:
>>> file=open(r'D:\ruanjian\1.txt','wb')
>>> a={'a':97}
>>> pickle.dump(a,file)
>>> file.close()
>>> file=open(r'D:\ruanjian\1.txt','rb')
>>> a_=pickle.load(file)
>>> a_
{'a': 97}
需要把打印的内容直接输出到文件里的时候:
>>> with open (r'D:\ruanjian\1.txt','w') as f:
... print ('hello,world!',file=f)
...
>>> with open (r'D:\ruanjian\1.txt') as f:
... f.read()
...
'hello,world!\n'
因为w方式对已存在的文件会清楚后写入,但有的时候我们不想覆盖原有的文件,我们可以使用如下方式:
>>> if not os.path.exists(r'D:\ruanjian\1.txt'):
... with open(r'D:\ruanjian\1.txt','wt') as f:
... f.write('hello,world')
... else:
... print ('file already exists')
...
file already exists
在python3.x中我们也可以使用这种方式来判断文件是否存在,存在的话会报错,不存在的话文件可以创建
>>> with open(r'D:ruanjian\2.txt','xt') as f:
... f.write('hello\n')
...
6
>>> with open(r'D:ruanjian\2.txt','xt') as f:
... f.write('hello\n')
...
Traceback (most recent call last):
File "", line 1, in
FileExistsError: [Errno 17] File exists: 'D:ruanjian\\2.txt'
文件在存储时也可以压缩存储,需要用到gzip或者bz2模块,在这两个模块中,默认是二进制模式,因此需要使用wt,rt等,指定text模式。读的时候使用rt,和read()。
压缩级别可以用compresslevel来设置,也可以使用open里的encoding,errors,newline等。
>>> with gzip.open(r'D:\ruanjian\1.gz','wt') as f:
... f.write('text')
...
4
>>> with gzip.open(r'D:\ruanjian\1.gz','rt') as f:
... f.read()
...
'text'
>>> with bz2.open(r'D:\ruanjian\1.bz2','wt') as f:
... f.write('hello,world')
...
11
>>> with bz2.open(r'D:\ruanjian\1.bz2','rt') as f:
... f.read()
...
'hello,world'
这要用到os模块里的方法,关于os模块可以查看公众号的历史消息,对os模块有详细的解释,这里只列出一些简单的方法:
>>> import os
>>> os.getcwd()
'/root/blog'
>>> os.listdir('.')
['_config.yml', 'node_modules', '.gitignore', 'source', 'db.json', 'themes', 'package.json', 'public', 'scaffolds', '.deploy_git']
#当需要判断是文件时
>>> files=[file for file in os.listdir('.') if os.path.isfile(os.path.join('.',file))]
>>> files
['_config.yml', '.gitignore', 'db.json', 'package.json']
欢迎各位关注我的微信公众号
另外有需要云服务器可以了解下创新互联scvps.cn,海内外云服务器15元起步,三天无理由+7*72小时售后在线,公司持有idc许可证,提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案,具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势,专为企业上云打造定制,能够满足用户丰富、多元化的应用场景需求。