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 fineI'm learning  Python

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

>>> print(r'I\'m fine')>>> print(r'I\'m learning \n Python')I\'m fineI\'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 / 33.3333333333333335

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

>>> 9 / 33.0

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

>>> 10 // 33

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

>>> 10 % 31

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

容器

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] = 555TypeError: '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)NoneNone -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)abcabcAbc

可以看到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 = 100if 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 = 0for x in [1,2,3,4,5]:    sum += xprint(sum)

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

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

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

while

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

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

break

break就是结束当前循环。

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

continue

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