Python基础(一)

数据类型和变量

整数

Python可以处理任意大小的整数,当然包括负整数,在程序中的表示方法和数学上的写法一模一样,例如:1,100,-8080,0,等等。
计算机由于使用二进制,所以,有时候用十六进制表示整数比较方便,十六进制用0x前缀和0-9,a-f表示,例如:0xff00,0xa5b4c3d2,等等。

浮点数

浮点数也就是小数,之所以称为浮点数,是因为按照科学记数法表示时,一个浮点数的小数点位置是可变的,比如,1.23x109和12.3x108是完全相等的。浮点数可以用数学写法,如1.23,3.14,-9.01,等等。但是对于很大或很小的浮点数,就必须用科学计数法表示,把10用e替代,1.23x109就是1.23e9,或者12.3e8,0.000012可以写成1.2e-5,等等。
整数和浮点数在计算机内部存储的方式是不同的,整数运算永远是精确的(除法难道也是精确的?是的!),而浮点数运算则可能会有四舍五入的误差。

字符串

字符串是以单引号’或双引号”括起来的任意文本,比如’abc’,”xyz”等等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 用加号连接字符串
>>> "Hello " + "world!"
'Hello world!'

# 字符串可以被当作字符列表
>>> "This is a string"[0]
'T'

# 用.format来格式化字符串
>>> "{} can be {}".format("strings", "interpolated")
'strings can be interpolated'

# 可以重复参数以节省时间
>>> "{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack", "candle stick")
'Jack be nimble, Jack be quick, Jack jump over the candle stick'

# 如果不想数参数,可以用关键字
>>> "{name} wants to eat {food}".format(name="Bob", food="lasagna")
'Bob wants to eat lasagna'

布尔值

一个布尔值只有True、False两种值,要么是True,要么是False,在Python中,可以直接用True、False表示布尔值(请注意大小写)

*用not取非

1
2
3
4
>>> not True 
False
>>> not False
True

布尔值可以用and、or和not运算。

1
2
3
4
5
6
>>> True and False
False
>>> True or False
True
>>> 5 > 3 or 1 > 3
True

整数也可以当作布尔值

1
2
3
4
5
6
7
8
9
10
>>> 0 and 2
0
>>> -5 or 0
-5
>>> 0 == False
True
>>> 2 == True
False
>>> 1 == True
True

list

list是Python内置的一种数据类型是列表:list。list是一种有序的集合,可以随时添加和删除其中的元素

1
2
3
4
# 用列表(list)储存序列
classmates = []
# 创建列表时也可以同时赋给元素
classmates = ['Michael', 'Bob', 'Tracy']

变量classmates就是一个list。用len()函数可以获得list元素的个数:

1
2
>>> len(classmates)
3

用索引来访问list中每一个位置的元素,记得索引是从0开始的:

1
2
>>> classmates[0]
'Michael'

当索引超出了范围时,Python会报一个IndexError错误,所以,要确保索引不要越界,记得最后一个元素的索引是len(classmates) - 1。
如果要取最后一个元素,除了计算索引位置外,还可以用-1做索引,直接获取最后一个元素:

1
2
>>> classmates[-1]
'Tracy'

list是一个可变的有序表,所以,可以往list中追加元素到末尾:

1
2
3
>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']

也可以把元素插入到指定的位置,比如索引号为1的位置:

1
2
3
>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

要删除list末尾的元素,用pop()方法:

1
2
3
4
>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']

要删除指定位置的元素,用pop(i)方法,其中i是索引位置:

1
2
3
4
>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']

要把某个元素替换成别的元素,可以直接赋值给对应的索引位置:
[‘Michael’, ‘Bob’, ‘Tracy’]

1
2
3
>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']

list里面的元素的数据类型也可以不同,比如:

1
>>> L = ['Apple', 123, True]

list元素也可以是另一个list,比如:

1
2
3
>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4

针对于获取列表指定索引范围的操作,Python提供了切片(Slice)操作符

获取数组的前3个元素,用一行代码就可以完成切片:

1
2
3
>>> L[0:3]
['Michael', 'Sarah', 'Tracy']
#L[0:3]表示,从索引0开始取,直到索引3为止,但不包括索引3。即索引0,1,2,正好是3个元素。

如果第一个索引是0,还可以省略:

1
2
>>> L[:3]
['Michael', 'Sarah', 'Tracy']

也可以从索引1开始,取出2个元素出来:

1
2
>>> L[1:3]
['Sarah', 'Tracy']

类似的,既然Python支持L[-1]取倒数第一个元素,那么它同样支持倒数切片,倒数第一个元素的索引是-1:

1
2
3
4
>>> L[-2:]
['Sarah', 'Tracy']
>>> L[-2:-1]
['Sarah']

切片操作十分有用。我们先创建一个0-99的数列:

1
2
3
>>> L = list(range(100))
>>> L
[0, 1, 2, 3, ..., 99]

可以通过切片轻松取出某一段数列。比如前10个数:

1
2
>>> L[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

前10个数,每两个取一个:

1
2
>>> L[:10:2]
[0, 2, 4, 6, 8]

所有数,每5个取一个:

1
2
>>> L[::5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

倒排列表

1
2
>>> L[::-1]
[99, 98, 97, 96, ..., 0]

甚至什么都不写,只写[:]就可以原样复制一个list:

1
2
>>> L[:]
[0, 1, 2, 3, ..., 99]

字符串也可以看成是一种list,每个元素就是一个字符。因此,字符串也可以用切片操作,只是操作结果仍是字符串:

1
2
3
4
>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'

在很多编程语言中,针对字符串提供了很多各种截取函数(例如,substring),其实目的就是对字符串切片。Python没有针对字符串的截取函数,只需要切片一个操作就可以完成,非常简单。

tuple(元组)

tuple和list非常类似,是一组有序的列表,可以存储不同的数据,但是tuple一旦初始化就不能修改,它没有append(),insert()这样的方法。其他获取元素的方法和list是一样的,你可以正常地使用classmates[0],classmates[-1],但不能赋值成另外的元素。

1
2
3
tup = (1, 2, 3)
tup[0] # => 1
tup[0] = 3 # 抛出TypeError

列表允许的操作元组大都可以

1
2
3
4
len(tup)   # => 3
tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6)
tup[:2] # => (1, 2)
2 in tup # => True

可以把元组合列表解包,赋值给变量

1
a, b, c = (1, 2, 3)     # 现在a是1,b是2,c是3

元组周围的括号是可以省略的

1
d, e, f = 4, 5, 6

交换两个变量的值就这么简单

1
e, d = d, e     # 现在d是5,e是4

dict

Python内置了字典:dict的支持,dict全称dictionary,在其他语言中也称为map,使用键-值(key-value)存储,具有极快的查找速度。
为什么dict查找速度这么快?因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字,我们要查某一个字,有两种方法:
一个办法是把字典从第一页往后翻,直到找到我们想要的字为止,这种方法就是在list中查找元素的方法,list越大,查找越慢。
第二种方法是先在字典的索引表里(比如部首表)查这个字对应的页码,然后直接翻到该页,找到这个字。无论找哪个字,这种查找速度都非常快,不会随着字典大小的增加而变慢。
dict就是第二种实现方式,给定一个名字,比如’Michael’,dict在内部就可以直接计算出Michael对应的存放成绩的“页码”,也就是对应值存放的内存地址,直接取出来,所以速度非常快。这种key-value存储方式,在放进去的时候,必须根据key算出value的存放位置,这样,取的时候才能根据key直接拿到value。

把数据放入dict的方法,除了初始化时指定外,还可以通过key放入:

1
2
3
4
>>> d = {}
>>> d['Adam'] = 67
>>> d['Adam']
67

由于一个key只能对应一个value,所以,多次对一个key放入value,后面的值会把前面的值冲掉,如果key不存在,dict就会报错:

1
2
3
4
>>> d[Tom]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'Tom' is not defined

要避免key不存在的错误,有两种办法,一是通过in判断key是否存在:

1
2
>>> 'Tom' in d
False

二是通过dict提供的get()方法,如果key不存在,可以返回None,或者自己指定的value:

1
2
3
4
5
>>> d.get('Tom')
>>> d.get('Tom', -1)
-1

#注意:返回None的时候Python的交互环境不显示结果。

要删除一个key,用pop(key)方法,对应的value也会从dict中删除:

1
2
>>> d.pop('Adam')
67

dict属于无序列表,dict内部存放的顺序和key放入的顺序是没有关系的,和list比较,dict有以下几个特点:
查找和插入的速度极快,不会随着key的增加而变慢;
需要占用大量的内存,内存浪费多。

而list相反:
查找和插入的时间随着元素的增加而增加;
占用空间小,浪费内存很少。
所以,dict是用空间来换取时间的一种方法。

dict可以用在需要高速查找的很多地方,在Python代码中几乎无处不在,正确使用dict非常重要,需要牢记的第一条就是dict的key必须是不可变对象。
这是因为dict根据key来计算value的存储位置,如果每次计算相同的key得出的结果不同,那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法(Hash)。
要保证hash的正确性,作为key的对象就不能变。在Python中,字符串、整数等都是不可变的,因此,可以放心地作为key。而list是可变的,就不能作为key:

set

set和dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key。
要创建一个set,需要提供一个list作为输入集合:

1
2
3
4
>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}
#注意,传入的参数[1, 2, 3]是一个list,而显示的{1, 2, 3}只是告诉你这个set内部有1,2,3这3个元素,显示的顺序也不表示set是有序的。。

重复元素在set中自动被过滤:

1
2
3
>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}

通过add(key)方法可以添加元素到set中,可以重复添加,但不会有效果:

1
2
3
4
5
6
>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)
>>> s
{1, 2, 3, 4}

通过remove(key)方法可以删除元素:

1
2
3
>>> s.remove(4)
>>> s
{1, 2, 3}

set可以看成数学意义上的无序和无重复元素的集合,因此,两个set可以做数学意义上的交集、并集等操作:

1
2
3
4
5
6
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

set和dict的唯一区别仅在于没有存储对应的value,但是,set的原理和dict一样,所以,同样不可以放入可变对象,因为无法判断两个可变对象是否相等,也就无法保证set内部“不会有重复元素”。试试把list放入set,看看是否会报错。

参考文章

廖雪峰Python教程
在编写代码的过程中会遇到很多语法和编码相关的警告和报错,相关的警告可以参考:
Python 语法警告

-------------本文结束感谢您的阅读-------------