【python】 - 基本语法总结（1）_0.0000089的科学记数法

【python】 - 基本语法总结（1）

1.1 数据类型

计算机可以处理不同类型的数据，文本，图形，音视频数据通过转换成数值型数据而被计算机直接所处理，这些直接所处理的数据类型包括：整数、浮点数、字符串、布尔值、空值。

1.1.1 整数

形如1,2,3,4，…的数字在数学上和程序中的表示方法一样，都属于整数类型。

1.1.2 浮点数

浮点数是通常现实中所见的小数，比如1.2，1.34,1.0000089等。
浮点数在计算机中的科学计数法表示为：计算机中1.34×10⁹表示成科学计数法为1.34e9，0.0000089表示成科学计数法为8.9e-6.

1.1.3 字符串

以单引号‘’或者双引号“”括起来的任意文本（不包括‘’或者“”）。
‘abc’字符串只包含a,b,c三个字符；
“I’m ok ” 字符串包含I ‘ m 空格 o k6个字符；
转义字符\
‘I’m ok’ #第二个/会将后边的’按字符输出

'I'm ok'  #输出错误

  File "<ipython-input-1-3ab66808fb8f>", line 1
    'I'm ok'  #输出错误
       ^
SyntaxError: invalid syntax
1
2
3
4

"I'm ok"

"I'm ok"
1

'I\'m ok'

"I'm ok"
1

1.1.4 布尔值

使用True、False表示布尔值。

True and True #与

True
1

True and False #与

False
1

not False #非

True
1

True or False #或

True
1

5<3

False
1

1.1.5 空值

Python中的特殊值，空值用None表示，不同于0值。

占位符

%d — 整数
%f — 浮点数
%s — 字符串
%x — 十六进制整数

Python同时提供了列表、字典等多种数据类型，还允许创建自定义数据类型。

1.2 列表、元组、字典与集合

list是一种有序的集合，可以随时添加和删除其中的元素。
添加元素可以有append,insert
删除元素可以有pop
替换元素
list里面的元素的数据类型可以不同。

note=['apple','banana','pear','peach']
print(note)
print(len(note)) #获取列表note中元素个数
print(note[0])  #按索引访问list中的元素
print(note[-1]) #获取列表中最后一个元素
print(note[-2]) #获取列表中倒数第二个元素
1
2
3
4
5

['apple', 'banana', 'pear', 'peach']
4
apple
peach
pear
1
2
3
4
5

#列表末尾追加元素
note.append('melon')
print(note)
1
2

['apple', 'banana', 'pear', 'peach', 'melon', 'melon']
1

#元素插入到指定位置，比如查到索引为1的位置
note.insert(1,'grape')
note
1
2

['apple', 'grape', 'grape', 'banana', 'pear', 'peach', 'melon', 'melon']
1

#删除list末尾的元素
note.pop()
1

'melon'
1

print(note)

['apple', 'grape', 'grape', 'banana', 'pear', 'peach', 'melon']
1

#删除指定位置的元素
note.pop(1)
1

'grape'
1

note

['apple', 'grape', 'banana', 'pear', 'peach', 'melon']
1

#替换元素
note[5]='water-melon'
note
1
2

['apple', 'grape', 'banana', 'pear', 'peach', 'water-melon']
1

#list中的元素可以不同
L=['Apple',12,True,'']
L
1
2

['Apple', 12, True, '']
1

tuple,元组与列表的区别是一旦初始化就不能被修改,tuple的不可变性，使得代码更加安全。

note=('apple','pear','grape')  #note元组没有append(),insert()方法。

#同样可以采用list获取元素的方法
note[-1]
1

'grape'
1

当定义只有一个元素的tuple时，不能这么写t=(1),而应该写作t=(1,)

#t=(1)中的小括号既可以表示tuple,也可以表示成数学公式中的小括号，
#在Python中，这种情况下，按小括号进行计算，计算结果就是1.
#所以在元组中的定义，需要加一个逗号，消除歧义
t=(1,)
t
1
2
3
4

(1,)
1

可变的tuple怎么看待

t=('apple','grape',['melon','pear'])  #tuple中定义了三个元素
t[2][0]='a'
t[2][1]='b'
t
1
2
3

('apple', 'grape', ['a', 'b'])
1

这个例子中元组可变的原因是，元组最后一个元素是列表，列表中的元素重新赋值后，元组中列表发生变化，但是元组第2个索引指向的位置没有发生变化

字典dict,使用键-值（key-value）存储，具有极快的查找速度。

#d={key1:value1,key2:value2,...}
d={'key1':1,'key2':2,'key3':3}
d['key1']
1
2

1
1

#查看key是否存在字典里
'key4' in d
1

False
1

d.get('key4') #key值不存在，返回None时，交互环境并没有显示
1

#可以在key不存在的情况下指定返回值
d.get('key4','-1')
1

'-1'
1

#删除key操作
d.pop('key1')
1

1
1

dict:

查找和插入的速度极快，不会随着key的增加而变慢；
需要占用大量的内存；

list:

查找和插入的时间随着元素的增加而增加；
占用空间小

dict同时存储key和value,根据key值计算value得位置，其中key是不可变对象，通过key计算value存储位置的算法称为哈希算法。
字符串，整数等都是不可变的，可以放心的用作于key值，list是可变的，不能作为key。

key5=[1,2,3]
d[key5]='list' #列表不能作为字典中的key值
1

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-9-4ff700c86b7b> in <module>()
      1 key5=[1,2,3]
----> 2 d[key5]='list' #列表不能作为字典中的key值


TypeError: unhashable type: 'list'
1
2
3
4
5
6
7
8
9
10

set集合，顾名思义，在数学中集合中不能同时存在两个一样的数字，在python中，set是一组key的集合，但不存储value,key值不能重复。

#定义一个set
s=set([1,2,3,4,4,5,6,6])
s
1
2

{1, 2, 3, 4, 5, 6}
1

#上边重复元素会被过滤
#结合添加元素
s.add(6)  #t添加重复元素，不会有效果
s
1
2
3

{1, 2, 3, 4, 5, 6}
1

#删除元素
s.remove(4)
s
1
2

{1, 2, 3, 5, 6}
1

#集合间的交并集
s1=set([1,2,3])
s2=set([2,3,4])
s1&s2 #交集
1
2
3

{2, 3}
1

s1|s2  #并集

{1, 2, 3, 4}
1

s=set([1,2,3,[1,2]])  #list不能放入set中

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-19-e311a47a3491> in <module>()
----> 1 s=set([1,2,3,[1,2]])  #list不能放入set中


TypeError: unhashable type: 'list'
1
2
3
4
5
6
7
8
9

a='abc'  #字符串是不可变对象
a.replace('a','A')
1

'Abc'
1

a

'abc'
1

a=['c','b','a'] #列表作为可变对象
a.sort()
a  #
1
2

['a', 'b', 'c']
1

1.3 文件操作

读写文件是最常见的IO操作，那么使用python语言如何操作呢？见下。

读写文件的过程请求操作系统打开一个文件对象（通常称为文件描述符），然后通过系统提供的接口从这个文件对象中读取数据（读文件），或者把数据写入这个文件对象（写文件）。

#读文件---使用python内置的open()函数
f=open('./test.txt','r')  #'r'表示读
1
2

f

<_io.TextIOWrapper name='./test.txt' mode='r' encoding='cp936'>
1

#文件打开成功，调用read（）方法可以一次读取文件的全部内容
f.read()
1

'你好！欢迎学习python读写文件。'
1

#最后通过调用close（）方法关闭文件，文件不关闭会占用操作系统的资源，同时操作系统同一时间能打开的文件数量也是有限的
f.close()
1

#当文件读写时都有可能产生IOError,一旦出错，后边文件的关闭就不会调用
#为了无论是否出错都能正确的关闭文件，我们可以使用try...finally来实现
try:
    f=open('./test.txt','r')
    print(f.read())
finally:
    if f:
        f.close()
        
1
2
3
4
5
6
7
8

你好！欢迎学习python读写文件。
1

#由于上边的写法在每次写都写那么多，比较繁琐，Python就引入了with语句自动调用close()
with open('./test.txt','r') as f:
    print(f.read())
1
2

你好！欢迎学习python读写文件。
1

#上面的写法不用调用f.close()f方法
#接下来，我们就看看read()方法
1

read()会一次性读取文件的全部内容，如果文件的内容很大，内存就会爆炸。所以可以采用read(size)的方法，每次最多读取size个字节的内容。
readline()可以每次读取一行内容
readlines()一次读取所有内容并按行返回list

若文件很小，read()一次性读取最方便；
若不能确定文件的大小，反复调用read(size)比较保险；
若是配置文件，调用readlines()最方便。

f=open('./test.txt','r')
for line in f.readlines():
    print(line.strip()) #把末尾的‘\n’删掉
f.close()
1
2
3

你好！欢迎学习python读写文件。
1

二进制文件读取

前面读取的是文本文件，并且是UTF-8编码的文本文件，要读取二进制文件，比如图片、视频等等，用‘rb’模式打开文件即可。

f=open('./Tulips.jpg','rb')
#f.read() #输出的是十六进制表示的字节
1

字符编码文件读取

在读取非UTF-8编码的文本文件时，需要给open()函数传入encoding参数，例如读取GBK编码的文件时，如下。

f=open('./gbk.txt',encoding='gbk')
f.read()
1

'你好，欢迎一起学习文件读写！'
1

若文件中含有编码不规范字符，可能会遇到UnicodeDecodeError,此时，open()函数还接受一个errors参数，表示遇到编码错误后如何处理。

#最简单的方式是直接忽略
f=open('./gbk.txt','r',encoding='gbk',errors='ignore')
f.read()
1
2

'你好，欢迎一起学习文件读写！你好，欢迎一起学习文件读写！你好，欢迎一起学习文件读写！ahjbvhjvjdknbnihaohuanyinxuexi '
1

f=open('./gbk.txt','r',errors='ignore')
f.read()
1

'你好，欢迎一起学习文件读写！你好，欢迎一起学习文件读写！你好，欢迎一起学习文件读写！ahjbvhjvjdknbnihaohuanyinxuexi '
1

写文件

在调用open（）函数时，传入标识符‘w’或者‘wb’表示写文本文件或写二进制文件

f=open('./test.txt','w')
f.write('Hello,world')  #在写文件时，操作系统往往不会立刻把数据写入磁盘，而是放到内存中缓存起来
f.close()  #只有调用close()方法时，操作系统才保证把没有写入的数据全部写入磁盘。
#因此，忘记调用close()的结果是数据可能只写一部分到磁盘了，剩下的丢失了
1
2
3

f=open('./test.txt','r')
f.read()
1

'Hello,world'
1

我们会发现原来test.txt的内容变了，这是因为‘w’会直接复写之前的内容，传入参数‘a’可以以追加的形式写入。

#保险的做法是使用with语句
with open('./test.txt','a') as f:
    f.write(',开始读写文件之旅！')
1
2

f=open('./test.txt','r')
f.read()
1

'Hello,world,开始读写文件之旅！'
1

同理，写入特定编码的文本文件，就给open()函数传入encoding参数，将字符串自动转换成指定编码。

with open('./gbk.txt','w',encoding='gbk') as f:
    f.write('你好，欢迎一起学习文件读写！')
1