Python基础成长记1

Python基础学习

1. 数据类型：

计算机顾名思义就是可以做数学计算的机器，因此它可以处理各种数值。但是计算机可以处理的不仅仅是数值，它还可以处理文本，音频，视频，网页等，不同的数据，需要定义不同的数据类型，python里面可以直接处理的数据类型有：

整数：

Python里面可以处理任意大小的整数，当然也包括负整数，在程序中的表现方法和数学中是一样的，100，-100等。由于计算机使用的是二进制，有时候，用十六进制表示比较方便，十六进制以0x前缀和0-9，a-f表示，0xff00,0x5b4c3等

浮点数：

浮点数也就是小数，为什么称为浮点数，因为按照科学记数法，浮点数的小数位是可以变的，1.23*10^9和12.3*10^8是完全相等的。浮点数的可以用数学表示：1.23，-2.45等，但是对于很大很小的浮点数，就必须用科学计数法，把10用e代替，1.23*e9,12.3*e8。0.000012可以写成1.2e-5等

字符串：

 字符串是一个用””或者’’括号起来任意引号，比如”ahd”,’ahfoiqw’等等，注意一点，””,’’这本身是一个表示方式，不是字符串的一部分。因此输出的字符串只有”ahd”只有a，b，c这三个字符。如果’本身也是一个字符可用””括号起来。字符串内包含’又包含”怎么办？可以用转义字符\来表示，比如：

I’am “OK”

I\’am \”OK\”

转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\，可以在Python的交互式命令行用print()打印字符串

如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r''表示''内部的字符串默认不转义

如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用'''...'''的格式表示多行内容，可以自己试试

 

布尔值：

布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来：

>>> 3>2

>>> True

>>> 2>3

>>> False

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

and运算是与运算，只有所有都为True，and运算结果才是True

or运算是或运算，只要其中有一个为True，or运算结果就是True

not运算是非运算，它是一个单目运算符，把True变成False，False变成True

 

空值:

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型，我们后面会继续讲到。

 

2.变量：

变量的概念基本上和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。

变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和_的组合，且不能用数字开头，比如：

A =1

变量A是一个整数

t_007 =’t_007’

变量t_007是一个字符串

Answer = True

变量Answer是一个布尔值

在python中，=是一个赋值语句，可以把任何数据类型赋值给变量，同一个变量可以反复赋值，可以是不同类型

这种变量本身是动态语言，与之对应的是静态语言。静态语言在定义变量的时候必须指定一个数据类型，如果赋值的数据类型不匹配，就会报错，比如

Int a = 123 这个时候指定了a是整数变量

a = “asd” 错误，不能把字符串赋给整数变量

和静态语言相比，动态语言更具有灵活性

 

不要把赋值语句等同于数学的等号，比如下面的代码：

X = 10

X = X+2

在数学中，X=X+2无论如何都是不成立的，在程序中，赋值语句先计算右边的X+2的表达式，得到的结果再赋值个左边的X，X的值最后是12。

最后，理解变量在计算机的内存：

a = ‘ABC’

这个时候python解释器干了两件事：

1. 在内存中创建了一个”ABC”的字符串；
2. 在内存中船舰了一个名为a的变量，并把它指向”ABC”。
3. 也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据

a = 'ABC'

b = a

a = 'XYZ'

print(b)

最后一行打印出变量b的内容到底是'ABC'呢还是'XYZ'？如果从数学意义上理解，就会错误地得出b和a相同，也应该是'XYZ'，但实际上b的值是'ABC'，让我们一行一行地执行代码，就可以看到到底发生了什么事：

执行a = 'ABC'，解释器创建了字符串'ABC'和变量a，并把a指向'ABC'：

执行b = a，解释器创建了变量b，并把b指向a指向的字符串'ABC'：

执行a = 'XYZ'，解释器创建了字符串'XYZ'，并把a的指向改为'XYZ'，但b并没有更改：

所以，最后打印变量b的结果自然是'ABC'了。

 

常量：

所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量：

PI = 3.1415926

但事实上PI仍然是一个变量，Python根本没有任何机制保证PI不会被改变，所以，用全部大写的变量名表示常量只是一个习惯上的用法，如果你一定要改变变量PI的值，也没人能拦住你。

注意：Python的整数没有大小限制，而某些语言的整数根据其存储长度是有大小限制的，例如Java对32位整数的范围限制在-2147483648-2147483647。

Python的浮点数也没有大小限制，但是超出一定范围就直接表示为inf（无限大）。

 

1. 字符串

字符串也是一种数据类型，字符串还有比较特殊的是一个编码问题

因为计算机只能处理数字，如果要处理文本，需要将文本转换为数字才能处理。最早的计算机设计时采用一个字节=8bit，所以一个字节能表达的最大整数是255，如果要表达更多的整数，可以采用两字节或者四字节

由于计算机是美国人发明的，最早有127个字符被编排到了ASCII码中，包含大小写字母，0-9和一些符号。

但是要处理中文显然一个字节不够，至少要两个字节，而且还不能和ASCII码冲突，所以中国定制了GB2312的编码，把中文编进去。

全世界有上百种语言，日本把日文编到Shift_JIS,韩国把韩文编到Euc-kr里，各国有各国的标准，那么就避免不了发生冲突，就会形成在多语言的文本中会显示码。

因此Unicode应运而生。Unicode把所有的语言都统一编到一套编码里面去，这样就不会出现乱码

如果统一成Unicode编码，乱码问题从此消失。但是如果你写的基本全是英文，用Unicode编码比ASCII码多一倍的存储空间，在存储上和传输上很不方便

所以，本着节约的精神，又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用UTF-8编码就能节省空间

UTF-8编码额外的一个好处，就是ASCII编码实际上可以看成UTF-8编码的一部分，那么ASCLL编码历史遗留下的软件可以在UTF-8下继续编码

计算机系统通过的字符编码工作方式：

在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码

用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件：

 

浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器：

所以你看到很多网页的源码上会有类似<meta charset="UTF-8" />的信息，表示该网页正是用的UTF-8编码。

 

 

Python的字符串:

在最新的Python 3版本中，字符串是以Unicode编码的，也就是说，Python的字符串支持多语言

对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符

由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes

Python对bytes类型的数据用带b前缀的单引号或双引号表示：

x = b'ABC'

要注意区分'ABC'和b'ABC'，前者是str，后者虽然内容显示得和前者一样，但bytes的每个字符都只占用一个字节。

纯英文的str可以用ASCII编码为bytes，内容是一样的，含有中文的str可以用UTF-8编码为bytes。含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错。

在bytes中，无法显示为ASCII字符的字节，用\x##显示

反过来，如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法：

如果bytes中包含无法解码的字节，decode()方法会报错

如果bytes中只有一小部分无效的字节，可以传入errors='ignore'忽略错误的字节：

>>> b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore')'中'

要计算str包含多少个字符，可以用len()函数：

>>> len('ABC')3

>>> len('中文')2

len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数：

>>> len(b'ABC')3

>>> len(b'\xe4\xb8\xad\xe6\x96\x87')6

>>> len('中文'.encode('utf-8'))6

在操作字符串时，我们经常遇到str和bytes的互相转换。为了避免乱码问题，应当始终坚持使用UTF-8编码对str和bytes进行转换。

 

由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

格式化

最后一个常见的问题是如何输出格式化的字符串。我们经常会输出类似'亲爱的xxx你好！你xx月的话费是xx，余额是xx'之类的字符串，而xxx的内容都是根据变量变化的，所以，需要一种简便的格式化字符串的方式

>>> 'Hello, %s' % 'world''Hello, world'

>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)

'Hi, Michael, you have $1000000.'

%运算符就是用来格式化字符串的。在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略

常见的占位符有：

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

 

其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：

如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串

有些时候，字符串里面的%是一个普通字符怎么办？这个时候就需要转义，用%%来表示一个%

format()

另一种格式化字符串的方法是使用字符串的format()方法，它会用传入的参数依次替换字符串内的占位符{0}、{1}……，不过这种方式写起来比%要麻烦得多：

>>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)'

Hello, 小明, 成绩提升了 17.1%

如果没有特殊业务要求，请牢记仅使用UTF-8编码。

格式化字符串的时候，可以用Python的交互式环境测试，方便快捷。

 

List

 

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

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

当索引超出了范围时，Python会报一个IndexError错误，所以，要确保索引不要越界，记得最后一个元素的索引是len(classmates) - 1。

如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素

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

>>> test.append('Adam')

>>> test

['Michael', 'Bob', 'Tracy', 'Adam']

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

>>> test.insert(1, 'Jack')

>>>test

['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

要删除list末尾的元素，用pop()方法：

>>>test.pop()'Adam'

>>> test

['Michael', 'Jack', 'Bob', 'Tracy']

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

>>> test.pop(1)'Jack'

>>> test

['Michael', 'Bob', 'Tracy']

要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：

>>> test[1] = 'Sarah'

>>> test

['Michael', 'Sarah', 'Tracy']

list里面的元素的数据类型也可以不同

list元素也可以是另一个list

 

Tuple

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改

>>> test = ('Michael', 'Bob', 'Tracy')

现在，test这个tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用test[0]，test[-1]，但不能赋值成另外的元素。

因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来，比如：

>>> s = (1, 2)

>>> s

(1, 2)

但是，要定义一个只有1个元素的tuple，如果你这么定义：

>>> s = (1)

>>> t1

定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。

所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：

>>> ts= (1,)

>>> t

(1,)

Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。

tuples虽然是不可变的，但是我们能使用另外一种方式让他成为为可变的

>>> t = ('a', 'b', ['A', 'B'])

>>> t[2][0] = 'X'

>>> t[2][1] = 'Y'

>>> t

('a', 'b', ['X', 'Y'])

这个tuples有三个元素，分别是’a’,’b’,list。为什么这样tuple就可以改变了呢？

看下图：

当我们把list的元素'A'和'B'修改为'X'和'Y'后，tuple变为：

 

 

从表面上来看，tuple确实是变了，但不是tuple的元素变了，是list的元素。Tuple的所谓的不变是指tuple的指向永远不变。如果指向了’a’就不能指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

 

list和tuple是Python内置的有序集合，一个可变，一个不可变。根据需要来选择使用它们