Python基础-数据类型和基础语法

数据类型

现代计算机能处理很多各种各样的数据，不同的数据就需要定义不同的数据类型，python中能够直接处理的数据类型有以下几种：

整数 可以是任意大小的整数，整数的运算永远是精确的，包括除法

浮点数 浮点数的运算可能有四舍五入的误差

字符串 是使用”或者”“括起来的任意文本例如’hello’, “world”。但是需要注意的是”或”“本身只是一种表示方式，不是字符串的一部分，因此，字符串’abc’只有a，b，c这3个字符。如果’本身也是一个字符，那就可以用”“括起来，比如”I’m OK”包含的字符是I，’，m，空格，O，K这6个字符。 关于转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\表示的字符就是\。我们可以测试一下

>>> print('I\'m fine') >>> print('I\'m learning \n Python') I'm fine I'm learning Python

其中python可以使用r”表示”内部的字符串不进行转义，例如上面的代码：

>>> print(r'I\'m fine') >>> print(r'I\'m learning \n Python') I\'m fine I\'m learning \n Python

布尔值 python使用True和False来表示布尔值，布尔值可以使用and、or、not运算分别是与、或、非，例如for循环、if语句等等都可以使用。

空值 在python中使用None表示它很特殊，不能理解为0，因为0是整数是有意义的。

除了上面的python还提供了列表、字典等多种数据类型我们在接下来讨论。

变量

python使用的是动态语言，与之相对的是静态语言，例如C++、Java。静态语言在定义变量是必须指定类型，例如：

int value = 5; value = "hehe" //这样是错误的

所以，动态语言更加灵活。

我们还需要理解计算机内存中是怎么处理变量的。 例如： val = ‘ABC’ python解释器进行了以下处理： 1. 在内存中创建了一个字符串’ABC’ 2. 在内存中创建了一个名为val的变量，并指向’ABC’

常量

一般使用全大写表示 PI = 3.14159265… 但是python其实并不能保证PI不会改变，所以这只是一个约定。

最后解释一下整数的除法为什么也是精确的。在Python中，有两种除法，一种除法是’/’：

>>> 10 / 3 3.3333333333333335

‘/’除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：

>>> 9 / 3 3.0

还有一种除法是’//’，称为地板除，两个整数的除法仍然是整数：

>>> 10 // 3 3

你没有看错，整数的地板除’//’永远是整数，即使除不尽。要做精确的除法，使用’/’就可以。 因为’//’除法只取结果的整数部分，所以Python还提供一个余数运算，可以得到两个整数相除的余数：

>>> 10 % 3 1

无论整数做’//’除法还是取余数，结果永远是整数，所以，整数运算结果永远是精确的。

容器

list

list是python内置的数据类型，可以任意添加、删除操作。 例如：

>>> names = ['Bob', 'Tom', 'Jk'] #获取某个、全部元素、以及list长度 >>> print(names) ['Bob', 'Tom', 'Jk'] >>> print(names[0], names[2]) Bob Jk >>> print(len(names)) 3 >>> print(names[-1], names[-2]) Jk Tom

增加和删除某一元素

#增加元素 >>> names.append('Michael') >>> print(names) ['Bob', 'Tom', 'Jk', 'Michael'] >>> names.insert(1, 'Jack') >>> print(names) ['Bob', 'Jack', 'Tom', 'Jk', 'Michael'] #删除元素 >>> names.pop() >>> print(names) ['Bob', 'Jack', 'Tom', 'Jk'] >>> print(names.pop(1)) Jack >>> print(names) ['Bob', 'Tom', 'Jk']

list中还可以存放不同类似的数据：

>>> lists = ['ABC', 123, 4.5,['a', True], None] >>> print(lists) >>> print(len(lists)) ['ABC', 123, 4.5, ['a', True], None] 5

tuple

它和list类似，但是tuple一旦初始化之后不可以修改！ tuple的使用以及注意事项如下：

>>> tup = ('hi', 321) >>> print(tup, len(tup), type(tup)) ('hi', 321) 2 <class 'tuple'> >>> tup = () >>> print(tup, len(tup), type(tup)) () 0 <class 'tuple'> #注意接下来两个的区别 >>> tup = ('A') >>> print(tup, len(tup), type(tup)) A 1 <class 'tuple'> #得到了一个错误 >>> tup = (9) >>> print(tup, len(tup), type(tup)) TypeError: object of type 'int' has no len()

看错误提示为什么tup变成了一个int？这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是9。

所以，只有1个元素(字符串最好也遵守这个规则)的tuple定义时必须加一个逗号，来消除歧义：

>>> tup = (9,) >>> print(tup, len(tup), type(tup)) (9,) 1 <class 'tuple'>

虽然说tuple不可修改，但是假如一个tuple包含了一个list会怎么样呢？

>>> tup = ('Str', 123, ['list', 321]) >>> print(tup[2][1]) 321 >>> tup[2][1] = True >>> print(tup[2][1]) True >>> tup[1] = 555 TypeError: 'tuple' object does not support item assignment

tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

dict

python中称为字典，在其它语言也称为map，使用键值对(key-value)存储数据，查找极快。 举例一个同学对应一个分数，我们就可以使用dict实现。

>>> d = {'Bob':89, 'Jack':30} >>> print(d) {'Bob': 89, 'Jack': 30}

或者修改一个同学的分数(没有会自动创建，相同会替换原来的数字)

>>> d['Lis'] = 59 >>> d['Bob'] = 100 >>> print(d) {'Bob': 100, 'Jack': 30, 'Lis': 59}

但是打印例如d[‘Tom’]这样不存在的key就会报错，所有我们最好判断一下：

if 'Tom' in d: print(d['Tom']) else: d['Tom'] = 66 print(d['Tom'])

或者使用get方法：

>>> print(d.get('Ben')) >>> print(d.get('Ben'), -1) None None -1

-1是自己设置的错误码。

删除一个key则可以使用pop(key)方法进行：

>>> print(d) >>> d.pop('Bob') >>> print(d) {'Bob': 100, 'Jack': 30, 'Lis': 59, 'Tom': 66} {'Jack': 30, 'Lis': 59, 'Tom': 66}

同样如果不存在会报错。 还有一点请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。 和list比较，dict有以下几个特点： 1. 查找和插入的速度极快，不会随着key的增加而变慢； 2. 需要占用大量的内存，内存浪费多。 而list相反： 1. 查找和插入的时间随着元素的增加而增加； 2. 占用空间小，浪费内存很少。 所以，dict是用空间来换取时间的一种方法。 dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。 这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。 要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key：

>>> key = [1, 2, 3] >>> d[key] = 'a list' Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unhashable type: 'list'

set

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

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

注意两点：一是重复key不会出现，二是set输出顺序不代表数据存储顺序！ 可以使用add()方法添加元素，remove删除元素，

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

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

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

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

不可变对象

在基本数据类型中，例如：str是不变对象，list是可变对象，例如：

>>> lists = ['a', 'c', 'b'] >>> lists.sort() # sorted(lists) 该函数返回一个list对象，为排序后的，不影响原来的list >>> print(lists) ['a', 'b', 'c']

但是str类型的数据

>>> a = 'abc' >>> print(a) >>> b = a.replace('a', 'A') >>> print(a) >>> print(b) abc abc Abc

可以看到a没有变还是’abc’，b才是’Abc’。 要始终牢记的是，a是变量，而’abc’才是字符串对象！有些时候，我们经常说，对象a的内容是’abc’，但其实是指，a本身是一个变量，它指向的对象的内容才是’abc’。 当我们调用a.replace(‘a’, ‘A’)时，实际上调用方法replace是作用在字符串对象’abc’上的，而这个方法虽然名字叫replace，但却没有改变字符串’abc’的内容。相反，replace方法创建了一个新字符串’Abc’并返回，如果我们用变量b指向该新字符串，就容易理解了，变量a仍指向原有的字符串’abc’，但变量b却指向新字符串’Abc’了。 所以，对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。

基础语法

条件判断

这个大家应该都能理解，举个例子说明一下：

score = 100 if score >= 90: print('best') else: print('general') >best

或者更加复杂一点的判断：

if score >= 90: print('best') elif score >= 60: print('good') else: print('general')

其中elif是 else if的缩写 只要判断语句是非零数值、非空字符串、非空list等，就判断为True，否则为False。

循环

for

例如我们想要计算1+2+….+100。直接写当然也可以，但是有循环的方法为什么不用呢。 简单的循环就先不看了，看一个稍微复杂一点的：

lists = ['String', 123, True, None] for elem in lists: print(elem) >String >123 >True >None

所以for xxx in xxxs循环就是把xxxs每个元素放入元素xxx中，然后执行代码。

例如我们想要计算1-5的和：

sum = 0 for x in [1,2,3,4,5]: sum += x print(sum)

但是怎么计算1-100呢，直接写也太长了。 我们可以使用range()方法：

for x in range(101): sum += x print(sum)

打印出结果5050，其中range(101)是生成了从0-100的整数序列。

while

还有一种循环是while，简单写一下

i = 10 i_list = [] while i > 5: i -= 1 i_list.append(i) print(i_list) #结果为[9,8,7,6,5]

break

break就是结束当前循环。

i = 10 i_list = [] while i > 5: if i < 8: break i -= 1 i_list.append(i) print(i_list) #结果为[9, 8, 7]

continue

==和C++、Java等语言一样。。。